Add IndexType parameter to GrDrawTarget::drawPaths

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
 
@@ skipping 17 matching lines @@
 
 class GrClipData;
 class GrDrawTargetCaps;
 class GrPath;
 class GrPathRange;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
-    typedef GrPathRendering::PathTransformType PathTransformType ;
+    typedef GrPathRange::PathIndexType PathIndexType;
+    typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
     // The context may not be fully constructed and should not be used during GrDrawTarget
     // construction.
     GrDrawTarget(GrContext* context);
     virtual ~GrDrawTarget();
 
     /**
      * Gets the capabilities of the draw target.
@@ skipping 223 matching lines @@
      */
     void stencilPath(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
 
     /**
      * 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(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
 
     /**
-     * Draws many paths. It will respect the HW
-     * antialias flag on the draw state (if possible in the 3D API).
+     * Draws the aggregate path from combining multiple. Note that this will not
+     * always be equivalent to back-to-back calls to drawPath(). It will respect
+     * the HW antialias flag on the draw state (if possible in the 3D API).
      *
-     * @param pathRange       Source of paths to draw from
-     * @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 transformsType  Type of transformations in the array. Array contains
-                              PathTransformSize(transformsType) * count elements
+     * @param pathRange       Source paths to draw from
+     * @param indices         Array of path indices to draw
+     * @param indexType       Data type of the array elements in indexBuffer
+     * @param transformValues Array of transforms for the individual paths
+     * @param transformType   Type of transforms in transformBuffer
+     * @param count           Number of paths to draw
      * @param fill            Fill type for drawing all the paths
      */
     void drawPaths(GrDrawState*, const GrPathRange* pathRange,
-                   const uint32_t indices[],
+                   const void* indices,
+                   PathIndexType indexType,
+                   const float transformValues[],
+                   PathTransformType transformType,
                    int count,
-                   const float transforms[],
-                   PathTransformType transformsType,
                    GrPathRendering::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 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 389 matching lines @@
                                const GrPath*,
                                const GrClipMaskManager::ScissorState&,
                                const GrStencilSettings&) = 0;
     virtual void onDrawPath(const GrDrawState&,
                             const GrPath*,
                             const GrClipMaskManager::ScissorState&,
                             const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) = 0;
     virtual void onDrawPaths(const GrDrawState&,
                              const GrPathRange*,
-                             const uint32_t indices[],
+                             const void* indices,
+                             PathIndexType,
+                             const float transformValues[],
+                             PathTransformType,
                              int count,
-                             const float transforms[],
-                             PathTransformType,
                              const GrClipMaskManager::ScissorState&,
                              const GrStencilSettings&,
                              const GrDeviceCoordTexture*) = 0;
 
     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
                          GrRenderTarget* renderTarget) = 0;
 
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
@@ skipping 82 matching lines @@
     virtual bool setupClip(const SkRect* devBounds,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
                            GrDrawState*,
                            GrClipMaskManager::ScissorState* scissorState) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif