Add IndexType parameter to GrDrawTarget::drawPaths

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 306 matching lines @@
     if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, scissorState, dstCopy)) {
         return;
     }
     DrawPath* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPath, (path));
     dp->fStencilSettings = stencilSettings;
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onDrawPaths(const GrDrawState& ds,
                                       const GrPathRange* pathRange,
-                                      const uint32_t indices[],
+                                      const void* indices,
+                                      PathIndexType indexType,
+                                      const float transformValues[],
+                                      PathTransformType transformType,
                                       int count,
-                                      const float transforms[],
-                                      PathTransformType transformsType,
                                       const GrClipMaskManager::ScissorState& scissorState,
                                       const GrStencilSettings& stencilSettings,
                                       const GrDeviceCoordTexture* dstCopy) {
     SkASSERT(pathRange);
     SkASSERT(indices);
-    SkASSERT(transforms);
+    SkASSERT(transformValues);
 
     if (!this->recordStateAndShouldDraw(ds, GrGpu::kDrawPath_DrawType, scissorState, dstCopy)) {
         return;
     }
 
-    uint32_t* savedIndices = fPathIndexBuffer.append(count, indices);
-    float* savedTransforms = fPathTransformBuffer.append(count *
-                                 GrPathRendering::PathTransformSize(transformsType), transforms);
+    int indexBytes = GrPathRange::PathIndexSizeInBytes(indexType);
+    if (int misalign = fPathIndexBuffer.count() % indexBytes) {
+        // Add padding to the index buffer so the indices are aligned properly.
+        fPathIndexBuffer.append(indexBytes - misalign);
+    }
+
+    char* savedIndices = fPathIndexBuffer.append(count * indexBytes,
+                                                 reinterpret_cast<const char*>(indices));
+    float* savedTransforms = fPathTransformBuffer.append(
+                                 count * GrPathRendering::PathTransformSize(transformType),
+                                 transformValues);
 
     if (kDrawPaths_Cmd == strip_trace_bit(fCmdBuffer.back().fType)) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stencilling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
         // places. For now the winding numbers are only an issue if the fill is even/odd,
         // because DrawPaths is currently only used for glyphs, and glyphs in the same
         // font tend to all wind in the same direction.
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
-            transformsType == previous->fTransformsType &&
+            indexType == previous->fIndexType &&
+            transformType == previous->fTransformType &&
             stencilSettings == previous->fStencilSettings &&
             path_fill_type_is_winding(stencilSettings) &&
             !ds.willBlendWithDst()) {
             // Fold this DrawPaths call into the one previous.
             previous->fCount += count;
             return;
         }
     }
 
     DrawPaths* dp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawPaths, (pathRange));
     dp->fIndicesLocation = savedIndices - fPathIndexBuffer.begin();
+    dp->fIndexType = indexType;
+    dp->fTransformsLocation = savedTransforms - fPathTransformBuffer.begin();
+    dp->fTransformType = transformType;
     dp->fCount = count;
-    dp->fTransformsLocation = savedTransforms - fPathTransformBuffer.begin();
-    dp->fTransformsType = transformsType;
     dp->fStencilSettings = stencilSettings;
 
     this->recordTraceMarkersIfNecessary();
 }
 
 void GrInOrderDrawBuffer::onClear(const SkIRect* rect, GrColor color,
                                   bool canIgnoreRect, GrRenderTarget* renderTarget) {
     SkASSERT(renderTarget);
     SkIRect r;
     if (NULL == rect) {
@@ skipping 134 matching lines @@
 void GrInOrderDrawBuffer::DrawPath::execute(GrInOrderDrawBuffer* buf,
                                             const GrOptDrawState* optState) {
     SkASSERT(optState);
     buf->fDstGpu->drawPath(*optState, this->path(), fStencilSettings);
 }
 
 void GrInOrderDrawBuffer::DrawPaths::execute(GrInOrderDrawBuffer* buf,
                                              const GrOptDrawState* optState) {
     SkASSERT(optState);
     buf->fDstGpu->drawPaths(*optState, this->pathRange(),
-                            &buf->fPathIndexBuffer[fIndicesLocation], fCount,
-                            &buf->fPathTransformBuffer[fTransformsLocation], fTransformsType,
-                            fStencilSettings);
+                            &buf->fPathIndexBuffer[fIndicesLocation], fIndexType,
+                            &buf->fPathTransformBuffer[fTransformsLocation], fTransformType,
+                            fCount, fStencilSettings);
 }
 
 void GrInOrderDrawBuffer::SetState::execute(GrInOrderDrawBuffer*, const GrOptDrawState*) {}
 
 void GrInOrderDrawBuffer::Clear::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState*) {
     if (GrColor_ILLEGAL == fColor) {
         buf->fDstGpu->discard(this->renderTarget());
     } else {
         buf->fDstGpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
@@ skipping 209 matching lines @@
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }