Move DrawInfo out from GrDrawTarget and rename to GrVertices.

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 18 matching lines @@
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrStencilAndCoverTextContext.h"
 #include "GrStrokeInfo.h"
 #include "GrSurfacePriv.h"
 #include "GrTextBlobCache.h"
 #include "GrTexturePriv.h"
 #include "GrTraceMarker.h"
 #include "GrTracing.h"
+#include "GrVertices.h"
 #include "SkDashPathPriv.h"
 #include "SkConfig8888.h"
 #include "SkGr.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "SkTLazy.h"
 #include "SkTLS.h"
 #include "SkTraceEvent.h"
 
 #include "effects/GrConfigConversionEffect.h"
@@ skipping 417 matching lines @@
         Geometry& args = fGeoData[0];
 
         int vertexCount = kVertsPerHairlineRect;
         if (args.fStrokeWidth > 0) {
             vertexCount = kVertsPerStrokeRect;
         }
 
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
 
-        void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
-                                                              vertexCount,
-                                                              &vertexBuffer,
-                                                              &firstVertex);
+        void* verts = batchTarget->vertexPool()->makeSpace(vertexStride,
+                                                           vertexCount,
+                                                           &vertexBuffer,
+                                                           &firstVertex);
 
-        if (!vertices) {
+        if (!verts) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
-        SkPoint* vertex = reinterpret_cast<SkPoint*>(vertices);
+        SkPoint* vertex = reinterpret_cast<SkPoint*>(verts);
 
         GrPrimitiveType primType;
 
         if (args.fStrokeWidth > 0) {;
             primType = kTriangleStrip_GrPrimitiveType;
             args.fRect.sort();
             this->setStrokeRectStrip(vertex, args.fRect, args.fStrokeWidth);
         } else {
             // hairline
             primType = kLineStrip_GrPrimitiveType;
             vertex[0].set(args.fRect.fLeft, args.fRect.fTop);
             vertex[1].set(args.fRect.fRight, args.fRect.fTop);
             vertex[2].set(args.fRect.fRight, args.fRect.fBottom);
             vertex[3].set(args.fRect.fLeft, args.fRect.fBottom);
             vertex[4].set(args.fRect.fLeft, args.fRect.fTop);
         }
 
-        GrDrawTarget::DrawInfo drawInfo;
-        drawInfo.init(primType, vertexBuffer, firstVertex, vertexCount);
-        batchTarget->draw(drawInfo);
+        GrVertices vertices;
+        vertices.init(primType, vertexBuffer, firstVertex, vertexCount);
+        batchTarget->draw(vertices);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     StrokeRectBatch(const Geometry& geometry) {
         this->initClassID<StrokeRectBatch>();
 
         fBatch.fHairline = geometry.fStrokeWidth == 0;
 
@@ skipping 287 matching lines @@
         size_t vertexStride = gp->getVertexStride();
 
         SkASSERT(vertexStride == sizeof(SkPoint) + (this->hasLocalCoords() ? sizeof(SkPoint) : 0)
                                                  + (this->hasColors() ? sizeof(GrColor) : 0));
 
         int instanceCount = fGeoData.count();
 
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
 
-        void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
-                                                              this->vertexCount(),
-                                                              &vertexBuffer,
+        void* verts = batchTarget->vertexPool()->makeSpace(vertexStride,
+                                                           this->vertexCount(),
+                                                           &vertexBuffer,
                                                               &firstVertex);
 
-        if (!vertices) {
+        if (!verts) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         const GrIndexBuffer* indexBuffer = NULL;
         int firstIndex = 0;
 
         void* indices = NULL;
         if (this->hasIndices()) {
             indices = batchTarget->indexPool()->makeSpace(this->indexCount(),
@@ skipping 12 matching lines @@
             const Geometry& args = fGeoData[i];
 
             // TODO we can actually cache this interleaved and then just memcopy
             if (this->hasIndices()) {
                 for (int j = 0; j < args.fIndices.count(); ++j, ++indexOffset) {
                     *((uint16_t*)indices + indexOffset) = args.fIndices[j] + vertexOffset;
                 }
             }
 
             for (int j = 0; j < args.fPositions.count(); ++j) {
-                *((SkPoint*)vertices) = args.fPositions[j];
+                *((SkPoint*)verts) = args.fPositions[j];
                 if (this->hasColors()) {
-                    *(GrColor*)((intptr_t)vertices + colorOffset) = args.fColors[j];
+                    *(GrColor*)((intptr_t)verts + colorOffset) = args.fColors[j];
                 }
                 if (this->hasLocalCoords()) {
-                    *(SkPoint*)((intptr_t)vertices + texOffset) = args.fLocalCoords[j];
+                    *(SkPoint*)((intptr_t)verts + texOffset) = args.fLocalCoords[j];
                 }
-                vertices = (void*)((intptr_t)vertices + vertexStride);
+                verts = (void*)((intptr_t)verts + vertexStride);
                 vertexOffset++;
             }
         }
 
-        GrDrawTarget::DrawInfo drawInfo;
+        GrVertices vertices;
         if (this->hasIndices()) {
-            drawInfo.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex,
+            vertices.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex,
                                  firstIndex, this->vertexCount(), this->indexCount());
 
         } else {
-            drawInfo.init(this->primitiveType(), vertexBuffer, firstVertex, this->vertexCount());
+            vertices.init(this->primitiveType(), vertexBuffer, firstVertex, this->vertexCount());
         }
-        batchTarget->draw(drawInfo);
+        batchTarget->draw(vertices);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     DrawVerticesBatch(const Geometry& geometry, GrPrimitiveType primitiveType,
                       const SkMatrix& viewMatrix,
                       const SkPoint* positions, int vertexCount,
                       const uint16_t* indices, int indexCount,
                       const GrColor* colors, const SkPoint* localCoords, const SkRect& bounds) {
@@ skipping 1006 matching lines @@
         fDrawBuffer->addGpuTraceMarker(marker);
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }