Add a GrPathRange class

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
 #include "GrClipData.h"
 #include "GrContext.h"
 #include "GrDrawState.h"
 #include "GrIndexBuffer.h"
 #include "GrTraceMarker.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 class GrClipData;
 class GrDrawTargetCaps;
 class GrPath;
+class GrPathRange;
 class GrVertexBuffer;
 
 class GrDrawTarget : public SkRefCnt {
 protected:
     class DrawInfo;
 
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
     ///////////////////////////////////////////////////////////////////////////
@@ skipping 303 matching lines @@
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
      * antialias flag on the draw state (if possible in the 3D API).
      */
     void drawPath(const GrPath*, SkPath::FillType fill);
 
     /**
      * Draws many paths. It will respect the HW
      * antialias flag on the draw state (if possible in the 3D API).
      *
-     * @param transforms array of 2d affine transformations, one for each path.
-     * @param fill the fill type for drawing all the paths. Fill must not be a
-     *             hairline.
-     * @param stroke the stroke for drawing all the paths.
+     * @param pathRange        Source of paths to draw from, stroke must not be

[bsalomon, 2014/07/17 17:27:28]

Is this comment right or should the hairline text be part of the fill param?

[Chris Dalton, 2014/07/17 18:15:19]

The old comment wasn't correct, hairline is a stroking style. The fill type is
winding/even-odd/inverse/etc.

But now that I think about it, we don't pass a stroke style to this method
anymore, so GrPathRange seems like the more natural place to enforce the no
hairline requirement. That's where we setup the nvpr stroking parameters, which
are what don't have hairline.

+     *                         hairline
+     * @param indices          Array of indices into the the pathRange
+     * @param count            Number of paths to draw (length of indices array)
+     * @param transforms       Array of individual transforms, one for each path
+     * @param transformsFormat Format of the transforms array. The array contains
+     *                         GrTransformSize(transformsFormat) × count elements
+     * @param fill             Fill type for drawing all the paths
      */
-    void drawPaths(int pathCount, const GrPath** paths,
-                   const SkMatrix* transforms, SkPath::FillType fill,
-                   SkStrokeRec::Style stroke);
+    void drawPaths(const GrPathRange* pathRange,
+                   const uint32_t indices[], int count,
+                   const float transforms[], GrTransformFormat transformsFormat,
+                   SkPath::FillType fill);
 
     /**
      * Helper function for drawing rects. It performs a geometry src push and pop
      * and thus will finalize any reserved geometry.
      *
      * @param rect        the rect to draw
      * @param matrix      optional matrix applied to rect (before viewMatrix)
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix optional matrix applied to localRect. If
@@ skipping 139 matching lines @@
      * For subclass internal use to invoke a call to onDrawPath().
      */
     void executeDrawPath(const GrPath* path, SkPath::FillType fill,
                          const GrDeviceCoordTexture* dstCopy) {
         this->onDrawPath(path, fill, dstCopy);
     }
 
     /**
      * For subclass internal use to invoke a call to onDrawPaths().
      */
-    void executeDrawPaths(int pathCount, const GrPath** paths,
-                          const SkMatrix* transforms, SkPath::FillType fill,
-                          SkStrokeRec::Style stroke,
+    void executeDrawPaths(const GrPathRange* pathRange,
+                          const uint32_t indices[], int count,
+                          const float transforms[], GrTransformFormat transformsFormat,
+                          SkPath::FillType fill,
                           const GrDeviceCoordTexture* dstCopy) {
-        this->onDrawPaths(pathCount, paths, transforms, fill, stroke, dstCopy);
+        this->onDrawPaths(pathRange, indices, count, transforms, transformsFormat, fill, dstCopy);
     }
 
     inline bool isGpuTracingEnabled() const {
         return this->getContext()->isGpuTracingEnabled();
     }
 
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * See AutoStateRestore below.
@@ skipping 368 matching lines @@
     // drawIndexedInstances, ...). The base class draws a two triangle fan using
     // drawNonIndexed from reserved vertex space.
     virtual void onDrawRect(const SkRect& rect,
                             const SkMatrix* matrix,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix);
 
     virtual void onStencilPath(const GrPath*, SkPath::FillType) = 0;
     virtual void onDrawPath(const GrPath*, SkPath::FillType,
                             const GrDeviceCoordTexture* dstCopy) = 0;
-    virtual void onDrawPaths(int, const GrPath**, const SkMatrix*,
-                             SkPath::FillType, SkStrokeRec::Style,
-                             const GrDeviceCoordTexture* dstCopy) = 0;
+    virtual void onDrawPaths(const GrPathRange*,
+                             const uint32_t indices[], int count,
+                             const float transforms[], GrTransformFormat,
+                             SkPath::FillType, const GrDeviceCoordTexture*) = 0;
 
     virtual void didAddGpuTraceMarker() = 0;
     virtual void didRemoveGpuTraceMarker() = 0;
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
 
@@ skipping 27 matching lines @@
     GrContext*                                                      fContext;
     // To keep track that we always have at least as many debug marker adds as removes
     int                                                             fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                fActiveTraceMarkers;
     GrTraceMarkerSet                                                fStoredTraceMarkers;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif