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

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
 #include "GrGLStencilAttachment.h"
@@ skipping 2053 matching lines @@
                 fHWScissorSettings.fEnabled = kYes_TriState;
             }
             return;
         }
     }
 
     // See fall through note above
     this->disableScissor();
 }
 
-bool GrGLGpu::flushGLState(const DrawArgs& args) {
+bool GrGLGpu::flushGLState(const GrPipeline& pipeline, const GrPrimitiveProcessor& primProc) {
     GrXferProcessor::BlendInfo blendInfo;
-    const GrPipeline& pipeline = *args.fPipeline;
-    args.fPipeline->getXferProcessor().getBlendInfo(&blendInfo);
+    pipeline.getXferProcessor().getBlendInfo(&blendInfo);
 
     this->flushColorWrite(blendInfo.fWriteColor);
     this->flushDrawFace(pipeline.getDrawFace());
 
-    SkAutoTUnref<GrGLProgram> program(fProgramCache->refProgram(args));
+    SkAutoTUnref<GrGLProgram> program(fProgramCache->refProgram(this, pipeline, primProc));
     if (!program) {
         GrCapsDebugf(this->caps(), "Failed to create program!\n");
         return false;
     }
 
     GrGLuint programID = program->programID();
     if (fHWProgramID != programID) {
         GL_CALL(UseProgram(programID));
         fHWProgramID = programID;
     }
 
     if (blendInfo.fWriteColor) {
         // Swizzle the blend to match what the shader will output.
         const GrSwizzle& swizzle = this->glCaps().glslCaps()->configOutputSwizzle(
-            args.fPipeline->getRenderTarget()->config());
+            pipeline.getRenderTarget()->config());
         this->flushBlend(blendInfo, swizzle);
     }
 
     SkSTArray<8, const GrTextureAccess*> textureAccesses;
-    program->setData(*args.fPrimitiveProcessor, pipeline, &textureAccesses);
+    program->setData(primProc, pipeline, &textureAccesses);
 
     int numTextureAccesses = textureAccesses.count();
     for (int i = 0; i < numTextureAccesses; i++) {
         this->bindTexture(i, textureAccesses[i]->getParams(),
                           static_cast<GrGLTexture*>(textureAccesses[i]->getTexture()));
     }
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(pipeline.getRenderTarget());
     this->flushStencil(pipeline.getStencil());
     this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), glRT->origin());
@@ skipping 50 matching lines @@
                              vbuf->bufferID(),
                              attribType,
                              stride,
                              reinterpret_cast<GrGLvoid*>(vertexOffsetInBytes + offset));
             offset += attrib.fOffset;
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }
 
-void GrGLGpu::buildProgramDesc(GrProgramDesc* desc,
-                               const GrPrimitiveProcessor& primProc,
-                               const GrPipeline& pipeline) const {
-    if (!GrGLProgramDescBuilder::Build(desc, primProc, pipeline, *this->glCaps().glslCaps())) {
-        SkDEBUGFAIL("Failed to generate GL program descriptor");
-    }
-}
-
 void GrGLGpu::bindBuffer(GrGLuint id, GrGLenum type) {
     this->handleDirtyContext();
     switch (type) {
         case GR_GL_ARRAY_BUFFER:
             this->bindVertexBuffer(id);
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             this->bindIndexBufferAndDefaultVertexArray(id);
             break;
         case GR_GL_TEXTURE_BUFFER:
@@ skipping 720 matching lines @@
                 GetWindowThreadProcessId(hwnd, &wndProcID);
                 if(wndProcID == procID) {
                     SwapBuffers(GetDC(hwnd));
                 }
                 hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
             }
          }
     #endif
 #endif
 
-void GrGLGpu::onDraw(const DrawArgs& args, const GrNonInstancedVertices& vertices) {
-    if (!this->flushGLState(args)) {
+void GrGLGpu::onDraw(const GrPipeline& pipeline,
+                     const GrPrimitiveProcessor& primProc,
+                     GrPrimitiveType primitiveType,
+                     const GrVertices* vertArray,
+                     int drawCount) {
+    if (!this->flushGLState(pipeline, primProc)) {
         return;
     }
+    GrPixelLocalStorageState plsState = primProc.getPixelLocalStorageState();
 
-    GrPixelLocalStorageState plsState = args.fPrimitiveProcessor->getPixelLocalStorageState();
-    if (!fHWPLSEnabled && plsState != 
-        GrPixelLocalStorageState::kDisabled_GrPixelLocalStorageState) {
-        GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        this->setupPixelLocalStorage(args);
-        fHWPLSEnabled = true;
-    }
-    if (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
-        GrStencilSettings stencil;
-        stencil.setDisabled();
-        this->flushStencil(stencil);
+
+    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 {
+            if (!fHWPLSEnabled && plsState !=

[egdaniel, 2016/03/16 19:55:35]

Ethan do you know if all this PLS stuff needs to stay inside the inner loop or
can any of it move out at all?

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

Seems like it could all move out since all we're doing here is un-instancing a
draw that the batch issued as a single logical draw.

[ethannicholas, 2016/03/16 21:14:19]

Agreed.

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

Done.

+                GrPixelLocalStorageState::kDisabled_GrPixelLocalStorageState) {
+                GL_CALL(Enable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
+                this->setupPixelLocalStorage(pipeline, primProc);
+                fHWPLSEnabled = true;
+            }
+            if (plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
+                GrStencilSettings stencil;
+                stencil.setDisabled();
+                this->flushStencil(stencil);
+            }
+
+            size_t indexOffsetInBytes = 0;
+            this->setupGeometry(primProc, *verts, &indexOffsetInBytes);
+
+            if (verts->isIndexed()) {
+                GrGLvoid* indices =
+                    reinterpret_cast<GrGLvoid*>(indexOffsetInBytes + sizeof(uint16_t) *
+                    verts->startIndex());
+                // info.startVertex() was accounted for by setupGeometry.
+                GL_CALL(DrawElements(gPrimitiveType2GLMode[primitiveType],
+                    verts->indexCount(),
+                    GR_GL_UNSIGNED_SHORT,
+                    indices));
+            } else {
+                // Pass 0 for parameter first. We have to adjust glVertexAttribPointer() to account
+                // for startVertex in the DrawElements case. So we always rely on setupGeometry to
+                // have accounted for startVertex.
+                GL_CALL(DrawArrays(gPrimitiveType2GLMode[primitiveType], 0,
+                    verts->vertexCount()));
+            }
+
+            if (fHWPLSEnabled &&
+                plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
+                // PLS draws always involve multiple draws, finishing up with a non-PLS
+                // draw that writes to the color buffer. That draw ends up here; we wait
+                // until after it is complete to actually disable PLS.
+                GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
+                fHWPLSEnabled = false;
+                this->disableScissor();
+            }
+
+            fStats.incNumDraws();
+        } while ((verts = iter.next()));
     }
 
-    size_t indexOffsetInBytes = 0;
-    this->setupGeometry(*args.fPrimitiveProcessor, vertices, &indexOffsetInBytes);
-
-    SkASSERT((size_t)vertices.primitiveType() < SK_ARRAY_COUNT(gPrimitiveType2GLMode));
-
-    if (vertices.isIndexed()) {
-        GrGLvoid* indices =
-            reinterpret_cast<GrGLvoid*>(indexOffsetInBytes + sizeof(uint16_t) *
-                                        vertices.startIndex());
-        // info.startVertex() was accounted for by setupGeometry.
-        GL_CALL(DrawElements(gPrimitiveType2GLMode[vertices.primitiveType()],
-                             vertices.indexCount(),
-                             GR_GL_UNSIGNED_SHORT,
-                             indices));
-    } else {
-        // Pass 0 for parameter first. We have to adjust glVertexAttribPointer() to account for
-        // startVertex in the DrawElements case. So we always rely on setupGeometry to have
-        // accounted for startVertex.
-        GL_CALL(DrawArrays(gPrimitiveType2GLMode[vertices.primitiveType()], 0,
-                           vertices.vertexCount()));
-    }
-
-    if (fHWPLSEnabled && plsState == GrPixelLocalStorageState::kFinish_GrPixelLocalStorageState) {
-        // PLS draws always involve multiple draws, finishing up with a non-PLS
-        // draw that writes to the color buffer. That draw ends up here; we wait
-        // until after it is complete to actually disable PLS.
-        GL_CALL(Disable(GR_GL_SHADER_PIXEL_LOCAL_STORAGE));
-        fHWPLSEnabled = false;
-        this->disableScissor();
-    }
 
 #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;
@@ skipping 23 matching lines @@
     if (!fHWStencilSettings.isDisabled()) {
         GL_CALL(Disable(GR_GL_STENCIL_TEST));
     }
     GL_CALL(DrawArrays(GR_GL_TRIANGLE_STRIP, 0, 4));
     GL_CALL(UseProgram(fHWProgramID));
     if (!fHWStencilSettings.isDisabled()) {
         GL_CALL(Enable(GR_GL_STENCIL_TEST));
     }
 }
 
-void GrGLGpu::setupPixelLocalStorage(const DrawArgs& args) {
+void GrGLGpu::setupPixelLocalStorage(const GrPipeline& pipeline,
+                                     const GrPrimitiveProcessor& primProc) {
     fPLSHasBeenUsed = true;
     const SkRect& bounds = 
-            static_cast<const GrPLSGeometryProcessor*>(args.fPrimitiveProcessor)->getBounds();
+            static_cast<const GrPLSGeometryProcessor&>(primProc).getBounds();
     // setup pixel local storage -- this means capturing and storing the current framebuffer color
     // and initializing the winding counts to zero
-    GrRenderTarget* rt = args.fPipeline->getRenderTarget();
+    GrRenderTarget* rt = pipeline.getRenderTarget();
     SkScalar width = SkIntToScalar(rt->width());
     SkScalar height = SkIntToScalar(rt->height());
     // dst rect edges in NDC (-1 to 1)
     // having some issues with rounding, just expand the bounds by 1 and trust the scissor to keep
     // it contained properly
     GrGLfloat dx0 = 2.0f * (bounds.left() - 1) / width - 1.0f;
     GrGLfloat dx1 = 2.0f * (bounds.right() + 1) / width - 1.0f;
     GrGLfloat dy0 = -2.0f * (bounds.top() - 1) / height + 1.0f;
     GrGLfloat dy1 = -2.0f * (bounds.bottom() + 1) / height + 1.0f;
     SkRect deviceBounds = SkRect::MakeXYWH(dx0, dy0, dx1 - dx0, dy1 - dy0);
@@ skipping 1358 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }