First step to moving vertex attributes to the geometryProcessor

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 295 matching lines @@
         drawState.setRenderTarget(texture->asRenderTarget());
 
         // if filtering is not desired then we want to ensure all
         // texels in the resampled image are copies of texels from
         // the original.
         GrTextureParams params(SkShader::kClamp_TileMode,
                                filter ? GrTextureParams::kBilerp_FilterMode :
                                         GrTextureParams::kNone_FilterMode);
         drawState.addColorTextureProcessor(clampedTexture, SkMatrix::I(), params);
 
-        drawState.setGeometryProcessor(
-                GrDefaultGeoProcFactory::CreateAndSetAttribs(
-                        &drawState,
-                        GrDefaultGeoProcFactory::kPosition_GPType |
-                        GrDefaultGeoProcFactory::kLocalCoord_GPType))->unref();
+        uint32_t flags = GrDefaultGeoProcFactory::kPosition_GPType |
+                         GrDefaultGeoProcFactory::kLocalCoord_GPType;
+        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create(flags);
+        drawState.setGeometryProcessor(gp)->unref();
 
-        GrDrawTarget::AutoReleaseGeometry arg(fDrawBuffer, 4, drawState.getVertexStride(),  0);
+        GrDrawTarget::AutoReleaseGeometry arg(fDrawBuffer, 4, gp->getVertexStride(),  0);
 
         if (arg.succeeded()) {
             SkPoint* verts = (SkPoint*) arg.vertices();
             verts[0].setIRectFan(0, 0, texture->width(), texture->height(), 2 * sizeof(SkPoint));
             verts[1].setIRectFan(0, 0, 1, 1, 2 * sizeof(SkPoint));
             fDrawBuffer->drawNonIndexed(&drawState, kTriangleFan_GrPrimitiveType, 0, 4);
         }
     } else {
         // TODO: Our CPU stretch doesn't filter. But we create separate
         // stretched textures when the texture params is either filtered or
@@ skipping 409 matching lines @@
         }
         return;
     }
 
     if (width >= 0) {
         // TODO: consider making static vertex buffers for these cases.
         // Hairline could be done by just adding closing vertex to
         // unitSquareVertexBuffer()
 
         static const int worstCaseVertCount = 10;
-        drawState.setDefaultVertexAttribs();
-        drawState.setGeometryProcessor(GrDefaultGeoProcFactory::Create(false))->unref();
+        const GrGeometryProcessor* gp = GrDefaultGeoProcFactory::Create();
+        drawState.setGeometryProcessor(gp)->unref();
         GrDrawTarget::AutoReleaseGeometry geo(target,
                                               worstCaseVertCount,
-                                              drawState.getVertexStride(),
+                                              gp->getVertexStride(),
                                               0);
 
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return;
         }
 
         GrPrimitiveType primType;
         int vertCount;
         SkPoint* vertex = geo.positions();
@@ skipping 50 matching lines @@
         *texOffset = sizeof(SkPoint) + sizeof(GrColor);
         flags |= GrDefaultGeoProcFactory::kColor_GPType |
                  GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (texCoords) {
         *texOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     } else if (colors) {
         *colorOffset = sizeof(SkPoint);
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
-    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::CreateAndSetAttribs(drawState,
-                                                                                 flags))->unref();
+    drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(flags))->unref();
 }
 
 void GrContext::drawVertices(const GrPaint& paint,
                              GrPrimitiveType primitiveType,
                              int vertexCount,
                              const SkPoint positions[],
                              const SkPoint texCoords[],
                              const GrColor colors[],
                              const uint16_t indices[],
                              int indexCount) {
     AutoCheckFlush acf(this);
     GrDrawState drawState;
     GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
     GrDrawTarget* target = this->prepareToDraw(&drawState, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     int colorOffset = -1, texOffset = -1;
     set_vertex_attributes(&drawState, texCoords, colors, &colorOffset, &texOffset);
 
-    size_t vertexStride = drawState.getVertexStride();
+    size_t vertexStride = drawState.getGeometryProcessor()->getVertexStride();
     if (!geo.set(target, vertexCount, vertexStride, indexCount)) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
     void* curVertex = geo.vertices();
 
     for (int i = 0; i < vertexCount; ++i) {
         *((SkPoint*)curVertex) = positions[i];
 
         if (texOffset >= 0) {
@@ skipping 671 matching lines @@
     if (ds) {
         if (paint) {
             SkASSERT(acf);
             ds->setFromPaint(*paint, fViewMatrix, fRenderTarget.get());
 #if GR_DEBUG_PARTIAL_COVERAGE_CHECK
             if ((paint->hasMask() || 0xff != paint->fCoverage) &&
                 !fDrawState->couldApplyCoverage(fGpu->caps())) {
                 SkDebugf("Partial pixel coverage will be incorrectly blended.\n");
             }
 #endif
-            // Clear any vertex attributes configured for the previous use of the
-            // GrDrawState which can effect which blend optimizations are in effect.
-            ds->setDefaultVertexAttribs();
         } else {
             ds->reset(fViewMatrix);
             ds->setRenderTarget(fRenderTarget.get());
         }
         ds->setState(GrDrawState::kClip_StateBit, fClip && !fClip->fClipStack->isWideOpen());
     }
     fDrawBuffer->setClip(fClip);
     return fDrawBuffer;
 }
 
@@ skipping 151 matching lines @@
     fResourceCache2->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif