Batch multiple single NVPR draw paths to instanced draws

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"
@@ skipping 127 matching lines @@
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
     if (glPath->shouldFill()) {
         GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
     }
     if (glPath->shouldStroke()) {
         GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
     }
 }
 
-void GrGLPathRendering::onDrawPath(const GrPipeline& pipeline,
-                                   const GrPrimitiveProcessor& primProc,
-                                   const GrStencilSettings& stencil,
-                                   const GrPath* path) {
-    if (!this->gpu()->flushGLState(pipeline, primProc)) {
-        return;
-    }
-    const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
-
-    this->flushPathStencilSettings(stencil);
-    SkASSERT(!fHWPathStencilSettings.isTwoSided());
-
-    GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
-        fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
-    GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
-
-    if (glPath->shouldStroke()) {
-        if (glPath->shouldFill()) {
-            GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
-        }
-        GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
-                                           GR_GL_BOUNDING_BOX));
-    } else {
-        GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
-                                         GR_GL_BOUNDING_BOX));
-    }
-}
-
 void GrGLPathRendering::onDrawPaths(const GrPipeline& pipeline,
                                     const GrPrimitiveProcessor& primProc,
-                                    const GrStencilSettings& stencil, const GrPathRange* pathRange,
+                                    const GrStencilSettings& stencil,
+                                    const GrPathRange* pathRange,
                                     const void* indices, PathIndexType indexType,
                                     const float transformValues[], PathTransformType transformType,
                                     int count) {
     SkDEBUGCODE(verify_floats(transformValues, gXformType2ComponentCount[transformType] * count));
 
     if (!this->gpu()->flushGLState(pipeline, primProc)) {
         return;
     }
     this->flushPathStencilSettings(stencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
@@ skipping 19 matching lines @@
                             0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues));
     } else {
         GL_CALL(StencilThenCoverFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues));
     }
 }
 
+void GrGLPathRendering::onDrawPaths(const GrPipeline& pipeline,
+                                    const GrPrimitiveProcessor& primProc,
+                                    const GrStencilSettings& stencil,
+                                    const GrPath* const* paths,
+                                    int count) {
+    if (count == 0) {

[bsalomon, 2016/04/22 13:20:39]

can just say !count if you prefer, not required

[Kimmo Kinnunen, 2016/04/25 08:36:00]

Done.

+        return;
+    }
+    if (!this->gpu()->flushGLState(pipeline, primProc)) {
+        return;
+    }
+    this->flushPathStencilSettings(stencil);
+    SkASSERT(!fHWPathStencilSettings.isTwoSided());
+
+    GrGLenum fillMode =
+        gr_stencil_op_to_gl_path_rendering_fill_mode(
+            fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLint writeMask =
+        fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
+    const GrGLPath* path = static_cast<const GrGLPath*>(paths[0]);
+    if (count > 1) {
+        SkAutoSTMalloc<32, GrGLuint> indexStorage(count);
+        for (int i = 0; i < count; ++i) {
+            indexStorage[i] = static_cast<const GrGLPath*>(paths[i])->pathID();
+        }
+        if (path->shouldStroke()) {
+            if (path->shouldFill()) {
+                GL_CALL(StencilFillPathInstanced(
+                    count, GR_GL_UNSIGNED_INT, indexStorage, 0,
+                    fillMode, writeMask, GR_GL_NONE, nullptr));
+            }
+            GL_CALL(StencilThenCoverStrokePathInstanced(
+                count, GR_GL_UNSIGNED_INT, indexStorage, 0, 0xffff, writeMask,
+                GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES, GR_GL_NONE, nullptr));
+        } else {
+            GL_CALL(StencilThenCoverFillPathInstanced(
+                count, GR_GL_UNSIGNED_INT, indexStorage, 0,
+                fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
+                GR_GL_NONE, nullptr));
+        }
+    } else {
+        if (path->shouldStroke()) {
+            if (path->shouldFill()) {
+                GL_CALL(StencilFillPath(path->pathID(), fillMode, writeMask));
+            }
+            GL_CALL(StencilThenCoverStrokePath(path->pathID(), 0xffff, writeMask,
+                                               GR_GL_BOUNDING_BOX));
+        } else {
+            GL_CALL(StencilThenCoverFillPath(path->pathID(), fillMode, writeMask,
+                                             GR_GL_BOUNDING_BOX));
+        }
+    }
+}
+
 void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
                                                              GrGLenum genMode, GrGLint components,
                                                              const SkMatrix& matrix) {
     float coefficients[3 * 3];
     SkASSERT(components >= 1 && components <= 3);
 
     coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
     coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
     coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
 
@@ skipping 105 matching lines @@
             funcMask != fHWPathStencilSettings.funcMask(kFront_Face)) {
             GL_CALL(PathStencilFunc(GrToGLStencilFunc(func), funcRef, funcMask));
         }
         fHWPathStencilSettings = stencilSettings;
     }
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }