Revert of Make setVertexAttribs in GrDrawState take a stride parameter.

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
@@ skipping 177 matching lines @@
         *indices = NULL;
     }
     return acquired;
 
 }
 
 bool GrDrawTarget::reserveVertexAndIndexSpace(int vertexCount,
                                               int indexCount,
                                               void** vertices,
                                               void** indices) {
-    size_t vertexStride = this->drawState()->getVertexStride();
+    size_t vertexSize = this->drawState()->getVertexSize();
     this->willReserveVertexAndIndexSpace(vertexCount, indexCount);
     if (vertexCount) {
-        if (!this->reserveVertexSpace(vertexStride, vertexCount, vertices)) {
+        if (!this->reserveVertexSpace(vertexSize, vertexCount, vertices)) {
             if (indexCount) {
                 this->resetIndexSource();
             }
             return false;
         }
     }
     if (indexCount) {
         if (!this->reserveIndexSpace(indexCount, indices)) {
             if (vertexCount) {
                 this->resetVertexSource();
@@ skipping 59 matching lines @@
             SkFAIL("Unknown Index Source Type.");
             break;
     }
 }
 
 void GrDrawTarget::setVertexSourceToArray(const void* vertexArray,
                                           int vertexCount) {
     this->releasePreviousVertexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fVertexSrc = kArray_GeometrySrcType;
-    geoSrc.fVertexSize = this->drawState()->getVertexStride();
+    geoSrc.fVertexSize = this->drawState()->getVertexSize();
     geoSrc.fVertexCount = vertexCount;
     this->onSetVertexSourceToArray(vertexArray, vertexCount);
 }
 
 void GrDrawTarget::setIndexSourceToArray(const void* indexArray,
                                          int indexCount) {
     this->releasePreviousIndexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fIndexSrc = kArray_GeometrySrcType;
     geoSrc.fIndexCount = indexCount;
     this->onSetIndexSourceToArray(indexArray, indexCount);
 }
 
 void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer) {
     this->releasePreviousVertexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fVertexSrc    = kBuffer_GeometrySrcType;
     geoSrc.fVertexBuffer = buffer;
     buffer->ref();
-    geoSrc.fVertexSize = this->drawState()->getVertexStride();
+    geoSrc.fVertexSize = this->drawState()->getVertexSize();
 }
 
 void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) {
     this->releasePreviousIndexSource();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     geoSrc.fIndexSrc     = kBuffer_GeometrySrcType;
     geoSrc.fIndexBuffer  = buffer;
     buffer->ref();
 }
 
@@ skipping 354 matching lines @@
 namespace {
 
 // position + (optional) texture coord
 extern const GrVertexAttrib gBWRectPosUVAttribs[] = {
     {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
     {kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttribBinding}
 };
 
 void set_vertex_attributes(GrDrawState* drawState, bool hasUVs) {
     if (hasUVs) {
-        drawState->setVertexAttribs<gBWRectPosUVAttribs>(2, 2 * sizeof(SkPoint));
+        drawState->setVertexAttribs<gBWRectPosUVAttribs>(2);
     } else {
-        drawState->setVertexAttribs<gBWRectPosUVAttribs>(1, sizeof(SkPoint));
+        drawState->setVertexAttribs<gBWRectPosUVAttribs>(1);
     }
 }
 
 };
 
 void GrDrawTarget::onDrawRect(const SkRect& rect,
                               const SkRect* localRect,
                               const SkMatrix* localMatrix) {
 
     set_vertex_attributes(this->drawState(), NULL != localRect);
 
     AutoReleaseGeometry geo(this, 4, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
-    size_t vstride = this->drawState()->getVertexStride();
-    geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vstride);
+    size_t vsize = this->drawState()->getVertexSize();
+    geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vsize);
     if (NULL != localRect) {
         SkPoint* coords = GrTCast<SkPoint*>(GrTCast<intptr_t>(geo.vertices()) +
                                             sizeof(SkPoint));
         coords->setRectFan(localRect->fLeft, localRect->fTop,
                            localRect->fRight, localRect->fBottom,
-                           vstride);
+                           vsize);
         if (NULL != localMatrix) {
-            localMatrix->mapPointsWithStride(coords, vstride, 4);
+            localMatrix->mapPointsWithStride(coords, vsize, 4);
         }
     }
     SkRect bounds;
     this->getDrawState().getViewMatrix().mapRect(&bounds, rect);
 
     this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4, &bounds);
 }
 
 void GrDrawTarget::clipWillBeSet(const GrClipData* clipData) {
 }
@@ skipping 416 matching lines @@
     SkASSERT(!fConfigTextureSupport[kUnknown_GrPixelConfig]);
 
     for (size_t i = 1; i < SK_ARRAY_COUNT(kConfigNames); ++i)  {
         r.appendf("%s is uploadable to a texture: %s\n",
                   kConfigNames[i],
                   gNY[fConfigTextureSupport[i]]);
     }
 
     return r;
 }