Remove GP from drawstate, revision of invariant output for GP

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpu.h"
 #include "GrInvariantOutput.h"
 #include "SkColorPriv.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
 };
 }
 
-static CoverageAttribType set_rect_attribs(GrDrawState* drawState, GrColor color) {
+static const GrGeometryProcessor* create_rect_gp(const GrDrawState& drawState, GrColor color,
+                                                 CoverageAttribType* type) {
     uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType;
-    if (drawState->canTweakAlphaForCoverage()) {
-        drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, flags))->unref();
-        SkASSERT(drawState->getGeometryProcessor()->getVertexStride() ==
-                 sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
-        return kUseColor_CoverageAttribType;
+    const GrGeometryProcessor* gp;
+    if (drawState.canTweakAlphaForCoverage()) {
+        gp = GrDefaultGeoProcFactory::Create(color, flags);
+        SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
+        *type = kUseColor_CoverageAttribType;
     } else {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
-        drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, flags))->unref();
-        SkASSERT(drawState->getGeometryProcessor()->getVertexStride() ==
-                 sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
-        return kUseCoverage_CoverageAttribType;
+        gp = GrDefaultGeoProcFactory::Create(color, flags, GrColorIsOpaque(color));
+        SkASSERT(gp->getVertexStride()==sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
+        *type = kUseCoverage_CoverageAttribType;
     }
+    return gp;
 }
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
 
 void GrAARectRenderer::reset() {
     SkSafeSetNull(fAAFillRectIndexBuffer);
@@ skipping 123 matching lines @@
 }
 
 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           GrColor color,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
                                           const SkRect& devRect) {
     GrDrawState::AutoRestoreEffects are(drawState);
 
-    CoverageAttribType covAttribType = set_rect_attribs(drawState, color);
-    if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(color)) {
-        drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
-    }
+    CoverageAttribType type;
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type));
 
-    size_t vstride = drawState->getGeometryProcessor()->getVertexStride();
-    GrDrawTarget::AutoReleaseGeometry geo(target, 8, vstride, 0);
+    size_t vertexStride = gp->getVertexStride();
+    GrDrawTarget::AutoReleaseGeometry geo(target, 8, vertexStride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
 
     if (NULL == fAAFillRectIndexBuffer) {
         fAAFillRectIndexBuffer = fGpu->createInstancedIndexBuffer(gFillAARectIdx,
                                                                   kIndicesPerAAFillRect,
                                                                   kNumAAFillRectsInIndexBuffer,
                                                                   kVertsPerAAFillRect);
     }
     GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer;
     if (NULL == indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
 
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
-    SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vstride);
+    SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride);
 
     SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
     inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
 
     if (combinedMatrix.rectStaysRect()) {
         // Temporarily #if'ed out. We don't want to pass in the devRect but
         // right now it is computed in GrContext::apply_aa_to_rect and we don't
         // want to throw away the work
 #if 0
         SkRect devRect;
         combinedMatrix.mapRect(&devRect, rect);
 #endif
 
-        set_inset_fan(fan0Pos, vstride, devRect, -SK_ScalarHalf, -SK_ScalarHalf);
-        set_inset_fan(fan1Pos, vstride, devRect, inset,  inset);
+        set_inset_fan(fan0Pos, vertexStride, devRect, -SK_ScalarHalf, -SK_ScalarHalf);
+        set_inset_fan(fan1Pos, vertexStride, devRect, inset,  inset);
     } else {
         // compute transformed (1, 0) and (0, 1) vectors
         SkVector vec[2] = {
           { combinedMatrix[SkMatrix::kMScaleX], combinedMatrix[SkMatrix::kMSkewY] },
           { combinedMatrix[SkMatrix::kMSkewX],  combinedMatrix[SkMatrix::kMScaleY] }
         };
 
         vec[0].normalize();
         vec[0].scale(SK_ScalarHalf);
         vec[1].normalize();
         vec[1].scale(SK_ScalarHalf);
 
         // create the rotated rect
         fan0Pos->setRectFan(rect.fLeft, rect.fTop,
-                            rect.fRight, rect.fBottom, vstride);
-        combinedMatrix.mapPointsWithStride(fan0Pos, vstride, 4);
+                            rect.fRight, rect.fBottom, vertexStride);
+        combinedMatrix.mapPointsWithStride(fan0Pos, vertexStride, 4);
 
         // Now create the inset points and then outset the original
         // rotated points
 
         // TL
-        *((SkPoint*)((intptr_t)fan1Pos + 0 * vstride)) =
-            *((SkPoint*)((intptr_t)fan0Pos + 0 * vstride)) + vec[0] + vec[1];
-        *((SkPoint*)((intptr_t)fan0Pos + 0 * vstride)) -= vec[0] + vec[1];
+        *((SkPoint*)((intptr_t)fan1Pos + 0 * vertexStride)) =
+            *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) + vec[0] + vec[1];
+        *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) -= vec[0] + vec[1];
         // BL
-        *((SkPoint*)((intptr_t)fan1Pos + 1 * vstride)) =
-            *((SkPoint*)((intptr_t)fan0Pos + 1 * vstride)) + vec[0] - vec[1];
-        *((SkPoint*)((intptr_t)fan0Pos + 1 * vstride)) -= vec[0] - vec[1];
+        *((SkPoint*)((intptr_t)fan1Pos + 1 * vertexStride)) =
+            *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) + vec[0] - vec[1];
+        *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) -= vec[0] - vec[1];
         // BR
-        *((SkPoint*)((intptr_t)fan1Pos + 2 * vstride)) =
-            *((SkPoint*)((intptr_t)fan0Pos + 2 * vstride)) - vec[0] - vec[1];
-        *((SkPoint*)((intptr_t)fan0Pos + 2 * vstride)) += vec[0] + vec[1];
+        *((SkPoint*)((intptr_t)fan1Pos + 2 * vertexStride)) =
+            *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) - vec[0] - vec[1];
+        *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) += vec[0] + vec[1];
         // TR
-        *((SkPoint*)((intptr_t)fan1Pos + 3 * vstride)) =
-            *((SkPoint*)((intptr_t)fan0Pos + 3 * vstride)) - vec[0] + vec[1];
-        *((SkPoint*)((intptr_t)fan0Pos + 3 * vstride)) += vec[0] - vec[1];
+        *((SkPoint*)((intptr_t)fan1Pos + 3 * vertexStride)) =
+            *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) - vec[0] + vec[1];
+        *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) += vec[0] - vec[1];
     }
 
     // Make verts point to vertex color and then set all the color and coverage vertex attrs values.
     verts += sizeof(SkPoint);
     for (int i = 0; i < 4; ++i) {
-        if (kUseCoverage_CoverageAttribType == covAttribType) {
-            *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
-            *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = 0;
+        if (kUseCoverage_CoverageAttribType == type) {
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
+            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
         } else {
-            *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
         }
     }
 
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
     }
 
-    verts += 4 * vstride;
+    verts += 4 * vertexStride;
 
     float innerCoverage = GrNormalizeByteToFloat(scale);
     GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
 
     for (int i = 0; i < 4; ++i) {
-        if (kUseCoverage_CoverageAttribType == covAttribType) {
-            *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
-            *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = innerCoverage;
+        if (kUseCoverage_CoverageAttribType == type) {
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
+            *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = innerCoverage;
         } else {
-            *reinterpret_cast<GrColor*>(verts + i * vstride) = scaledColor; 
+            *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexedInstances(drawState,
+                                 gp,
                                  kTriangles_GrPrimitiveType,
                                  1,
                                  kVertsPerAAFillRect,
                                  kIndicesPerAAFillRect);
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
                                     GrDrawState* drawState,
                                     GrColor color,
@@ skipping 65 matching lines @@
 }
 
 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
                                             GrDrawState* drawState,
                                             GrColor color,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
                                             bool miterStroke) {
     GrDrawState::AutoRestoreEffects are(drawState);
-    CoverageAttribType covAttribType = set_rect_attribs(drawState, color);
 
-    if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(color)) {
-        drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
-    }
+    CoverageAttribType type;
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type));
 
     int innerVertexNum = 4;
     int outerVertexNum = miterStroke ? 4 : 8;
     int totalVertexNum = (outerVertexNum + innerVertexNum) * 2;
 
-    size_t vstride = drawState->getGeometryProcessor()->getVertexStride();
+    size_t vstride = gp->getVertexStride();
     GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, vstride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
     GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke);
     if (NULL == indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
         return;
     }
@@ skipping 44 matching lines @@
         // inner one of the inner two
         set_inset_fan(fan2Pos, vstride, devInside,  -inset, -inset);
         // innermost
         set_inset_fan(fan3Pos, vstride, devInside,   SK_ScalarHalf,  SK_ScalarHalf);
     }
 
     // Make verts point to vertex color and then set all the color and coverage vertex attrs values.
     // The outermost rect has 0 coverage
     verts += sizeof(SkPoint);
     for (int i = 0; i < outerVertexNum; ++i) {
-        if (kUseCoverage_CoverageAttribType == covAttribType) {
+        if (kUseCoverage_CoverageAttribType == type) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
         }
     }
 
     // scale is the coverage for the the inner two rects.
     int scale;
     if (inset < SK_ScalarHalf) {
         scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
         SkASSERT(scale >= 0 && scale <= 255);
     } else {
         scale = 0xff;
     }
 
     float innerCoverage = GrNormalizeByteToFloat(scale);
     GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
 
     verts += outerVertexNum * vstride;
     for (int i = 0; i < outerVertexNum + innerVertexNum; ++i) {
-        if (kUseCoverage_CoverageAttribType == covAttribType) {
+        if (kUseCoverage_CoverageAttribType == type) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = innerCoverage;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = scaledColor;
         }
     }
 
     // The innermost rect has 0 coverage
     verts += (outerVertexNum + innerVertexNum) * vstride;
     for (int i = 0; i < innerVertexNum; ++i) {
-        if (kUseCoverage_CoverageAttribType == covAttribType) {
+        if (kUseCoverage_CoverageAttribType == type) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
     target->drawIndexedInstances(drawState,
+                                 gp,
                                  kTriangles_GrPrimitiveType,
                                  1,
                                  totalVertexNum,
                                  aa_stroke_rect_index_count(miterStroke));
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
                                          GrDrawState* drawState,
                                          GrColor color,
                                          const SkRect rects[2],
                                          const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
     SkASSERT(!rects[1].isEmpty());
 
     SkRect devOutside, devOutsideAssist, devInside;
     combinedMatrix.mapRect(&devOutside, rects[0]);
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(target, drawState, color, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     this->geometryStrokeAARect(target, drawState, color, devOutside, devOutsideAssist, devInside,
                                true);
 }