Add a GrPathRange class

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"
 #include "GrDrawTargetCaps.h"
 #include "GrTextStrike.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrPath.h"
+#include "GrPathRange.h"
 #include "GrRenderTarget.h"
 #include "GrTemplates.h"
 #include "GrTexture.h"
 #include "GrVertexBuffer.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrGpu* gpu,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
     : GrDrawTarget(gpu->getContext())
     , fDstGpu(gpu)
@@ skipping 386 matching lines @@
     }
 }
 
 GrInOrderDrawBuffer::StencilPath::StencilPath() {}
 GrInOrderDrawBuffer::DrawPath::DrawPath() {}
 GrInOrderDrawBuffer::DrawPaths::DrawPaths() {}
 GrInOrderDrawBuffer::DrawPaths::~DrawPaths() {
     if (fTransforms) {
         SkDELETE_ARRAY(fTransforms);
     }
-    for (int i = 0; i < fPathCount; ++i) {
-        fPaths[i]->unref();
+    if (fIndices) {
+        SkDELETE_ARRAY(fIndices);
     }
-    SkDELETE_ARRAY(fPaths);
 }
 
 void GrInOrderDrawBuffer::onStencilPath(const GrPath* path, SkPath::FillType fill) {
     if (this->needsNewClip()) {
         this->recordClip();
     }
     // Only compare the subset of GrDrawState relevant to path stenciling?
     if (this->needsNewState()) {
         this->recordState();
     }
@@ skipping 14 matching lines @@
     }
     DrawPath* cp = this->recordDrawPath();
     cp->fPath.reset(path);
     path->ref();
     cp->fFill = fill;
     if (NULL != dstCopy) {
         cp->fDstCopy = *dstCopy;
     }
 }
 
-void GrInOrderDrawBuffer::onDrawPaths(int pathCount, const GrPath** paths,
-                                      const SkMatrix* transforms,
-                                      SkPath::FillType fill,
-                                      SkStrokeRec::Style stroke,
-                                      const GrDeviceCoordTexture* dstCopy) {
-    SkASSERT(pathCount);
+void GrInOrderDrawBuffer::onDrawPaths(const GrPathRange* pathRange,
+                                      const uint32_t indices[], int count,
+                                      const float transforms[], PathTransformType transformsType,
+                                      SkPath::FillType fill, const GrDeviceCoordTexture* dstCopy) {
+    SkASSERT(NULL != pathRange);
+    SkASSERT(NULL != indices);
+    SkASSERT(NULL != transforms);
 
     if (this->needsNewClip()) {
         this->recordClip();
     }
     if (this->needsNewState()) {
         this->recordState();
     }
     DrawPaths* dp = this->recordDrawPaths();
-    dp->fPathCount = pathCount;
-    dp->fPaths = SkNEW_ARRAY(const GrPath*, pathCount);
-    memcpy(dp->fPaths, paths, sizeof(GrPath*) * pathCount);
-    for (int i = 0; i < pathCount; ++i) {
-        dp->fPaths[i]->ref();
-    }
+    dp->fPathRange.reset(SkRef(pathRange));
+    dp->fIndices = SkNEW_ARRAY(uint32_t, count); // TODO: Accomplish this without a malloc
+    memcpy(dp->fIndices, indices, sizeof(uint32_t) * count);
+    dp->fCount = count;
 
-    dp->fTransforms = SkNEW_ARRAY(SkMatrix, pathCount);
-    memcpy(dp->fTransforms, transforms, sizeof(SkMatrix) * pathCount);
+    const int transformsLength = PathTransformSize(transformsType) * count;
+    dp->fTransforms = SkNEW_ARRAY(float, transformsLength);
+    memcpy(dp->fTransforms, transforms, sizeof(float) * transformsLength);
+    dp->fTransformsType = transformsType;
 
     dp->fFill = fill;
-    dp->fStroke = stroke;
 
     if (NULL != dstCopy) {
         dp->fDstCopy = *dstCopy;
     }
 }
 
 void GrInOrderDrawBuffer::clear(const SkIRect* rect, GrColor color,
                                 bool canIgnoreRect, GrRenderTarget* renderTarget) {
     SkIRect r;
     if (NULL == renderTarget) {
@@ skipping 130 matching lines @@
                                          NULL != drawPathIter->fDstCopy.texture() ?
                                             &drawPathIter->fDstCopy :
                                             NULL);
                 break;
             }
             case kDrawPaths_Cmd: {
                 SkASSERT(fDstGpu->drawState() != prevDrawState);
                 SkAssertResult(drawPathsIter.next());
                 const GrDeviceCoordTexture* dstCopy =
                     NULL !=drawPathsIter->fDstCopy.texture() ? &drawPathsIter->fDstCopy : NULL;
-                fDstGpu->executeDrawPaths(drawPathsIter->fPathCount, drawPathsIter->fPaths,
-                                          drawPathsIter->fTransforms, drawPathsIter->fFill,
-                                          drawPathsIter->fStroke, dstCopy);
+                fDstGpu->executeDrawPaths(drawPathsIter->fPathRange.get(),
+                                          drawPathsIter->fIndices,
+                                          drawPathsIter->fCount,
+                                          drawPathsIter->fTransforms,
+                                          drawPathsIter->fTransformsType,
+                                          drawPathsIter->fFill,
+                                          dstCopy);
                 break;
             }
             case kSetState_Cmd:
                 SkAssertResult(stateIter.next());
                 fDstGpu->setDrawState(stateIter.get());
                 break;
             case kSetClip_Cmd:
                 SkAssertResult(clipIter.next());
                 clipData.fClipStack = &clipIter->fStack;
                 clipData.fOrigin = clipIter->fOrigin;
@@ skipping 339 matching lines @@
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
     this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }