Remove GP from drawstate, revision of invariant output for GP

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrProcessor.h"
@@ skipping 126 matching lines @@
         fInCircleEdge = &this->addVertexAttrib(GrAttribute("inCircleEdge",
                                                            kVec4f_GrVertexAttribType));
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
         return cee.fStroke == fStroke;
     }
 
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
-        inout->mulByUnknownAlpha();
+    virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+        out->setUnknownSingleComponent();
     }
 
     const GrAttribute* fInPosition;
     const GrAttribute* fInCircleEdge;
     bool fStroke;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
@@ skipping 124 matching lines @@
         fInEllipseRadii = &this->addVertexAttrib(GrAttribute("inEllipseRadii",
                                                              kVec4f_GrVertexAttribType));
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>();
         return eee.fStroke == fStroke;
     }
 
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
-        inout->mulByUnknownAlpha();
+    virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+        out->setUnknownSingleComponent();
     }
 
     const GrAttribute* fInPosition;
     const GrAttribute* fInEllipseOffset;
     const GrAttribute* fInEllipseRadii;
     bool fStroke;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 143 matching lines @@
         fInEllipseOffsets1 = &this->addVertexAttrib(GrAttribute("inEllipseOffsets1",
                                                                 kVec2f_GrVertexAttribType));
         fMode = mode;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>();
         return eee.fMode == fMode;
     }
 
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
-        inout->mulByUnknownAlpha();
+    virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const SK_OVERRIDE {
+        out->setUnknownSingleComponent();
     }
 
     const GrAttribute* fInPosition;
     const GrAttribute* fInEllipseOffsets0;
     const GrAttribute* fInEllipseOffsets1;
     Mode fMode;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 85 matching lines @@
         } else {
             halfWidth = SkScalarHalf(strokeWidth);
         }
 
         outerRadius += halfWidth;
         if (isStrokeOnly) {
             innerRadius = radius - halfWidth;
         }
     }
 
-    GrGeometryProcessor* gp = CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0);
-    drawState->setGeometryProcessor(gp)->unref();
+    SkAutoTUnref<GrGeometryProcessor> gp(
+            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(CircleVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
 
     CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices());
 
@@ skipping 25 matching lines @@
     verts[2].fOffset = SkPoint::Make(outerRadius, outerRadius);
     verts[2].fOuterRadius = outerRadius;
     verts[2].fInnerRadius = innerRadius;
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOffset = SkPoint::Make(outerRadius, -outerRadius);
     verts[3].fOuterRadius = outerRadius;
     verts[3].fInnerRadius = innerRadius;
 
     target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
-    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
+    target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
                                  GrDrawState* drawState,
                                  GrColor color,
                                  const GrContext* context,
                                  bool useCoverageAA,
@@ skipping 59 matching lines @@
 
         xRadius += scaledStroke.fX;
         yRadius += scaledStroke.fY;
     }
 
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return false;
     }
 
-    GrGeometryProcessor* gp = EllipseEdgeEffect::Create(color,
-                                                        isStrokeOnly &&
-                                                        innerXRadius > 0 && innerYRadius > 0);
-
-    drawState->setGeometryProcessor(gp)->unref();
+    SkAutoTUnref<GrGeometryProcessor> gp(
+            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(EllipseVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices());
 
@@ skipping 30 matching lines @@
     verts[2].fOffset = SkPoint::Make(xRadius, yRadius);
     verts[2].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
     verts[2].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOffset = SkPoint::Make(xRadius, -yRadius);
     verts[3].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
     verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
     target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
-    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
+    target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target,
                                    GrDrawState* drawState,
                                    GrColor color,
                                    const GrContext* context,
                                    bool useCoverageAA,
@@ skipping 44 matching lines @@
         xRadius += strokeWidth;
         yRadius += strokeWidth;
     }
     if (DIEllipseEdgeEffect::kStroke == mode) {
         mode = (innerXRadius > 0 && innerYRadius > 0) ? DIEllipseEdgeEffect::kStroke :
                                                         DIEllipseEdgeEffect::kFill;
     }
     SkScalar innerRatioX = SkScalarDiv(xRadius, innerXRadius);
     SkScalar innerRatioY = SkScalarDiv(yRadius, innerYRadius);
 
-    GrGeometryProcessor* gp = DIEllipseEdgeEffect::Create(color, mode);
-
-    drawState->setGeometryProcessor(gp)->unref();
+    SkAutoTUnref<GrGeometryProcessor> gp(DIEllipseEdgeEffect::Create(color, mode));
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, gp->getVertexStride(),  0);
     SkASSERT(gp->getVertexStride() == sizeof(DIEllipseVertex));
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(geo.vertices());
 
@@ skipping 25 matching lines @@
 
     verts[2].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
     verts[2].fOuterOffset = SkPoint::Make(1.0f + offsetDx, 1.0f + offsetDy);
     verts[2].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, innerRatioY + offsetDy);
 
     verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
     verts[3].fOuterOffset = SkPoint::Make(1.0f + offsetDx, -1.0f - offsetDy);
     verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy);
 
     target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
-    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
+    target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const uint16_t gRRectIndices[] = {
     // corners
     0, 1, 5, 0, 5, 4,
@@ skipping 199 matching lines @@
 
             if (isStrokeOnly) {
                 innerRadius = xRadius - halfWidth;
             }
             outerRadius += halfWidth;
             bounds.outset(halfWidth, halfWidth);
         }
 
         isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
 
-        GrGeometryProcessor* effect = CircleEdgeEffect::Create(color, isStrokeOnly);
-        drawState->setGeometryProcessor(effect)->unref();
+        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(CircleVertex));
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return false;
         }
         CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices());
 
         // The radii are outset for two reasons. First, it allows the shader to simply perform
@@ skipping 41 matching lines @@
             verts->fOffset = SkPoint::Make(outerRadius, yOuterRadii[i]);
             verts->fOuterRadius = outerRadius;
             verts->fInnerRadius = innerRadius;
             verts++;
         }
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
-        target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
+        target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
 
     // otherwise we use the ellipse renderer
     } else {
         SkScalar innerXRadius = 0.0f;
         SkScalar innerYRadius = 0.0f;
         if (hasStroke) {
             if (SkScalarNearlyZero(scaledStroke.length())) {
                 scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf);
             } else {
@@ skipping 18 matching lines @@
                 innerYRadius = yRadius - scaledStroke.fY;
             }
 
             xRadius += scaledStroke.fX;
             yRadius += scaledStroke.fY;
             bounds.outset(scaledStroke.fX, scaledStroke.fY);
         }
 
         isStrokeOnly = (isStrokeOnly && innerXRadius >= 0 && innerYRadius >= 0);
 
-        GrGeometryProcessor* effect = EllipseEdgeEffect::Create(color, isStrokeOnly);
-        drawState->setGeometryProcessor(effect)->unref();
+        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly));
 
         GrDrawTarget::AutoReleaseGeometry geo(target, 16, effect->getVertexStride(),  0);
         SkASSERT(effect->getVertexStride() == sizeof(EllipseVertex));
         if (!geo.succeeded()) {
             SkDebugf("Failed to get space for vertices!\n");
             return false;
         }
 
         EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices());
 
@@ skipping 46 matching lines @@
             verts->fOffset = SkPoint::Make(xOuterRadius, yOuterOffsets[i]);
             verts->fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts->fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
             verts++;
         }
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
-        target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
+        target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
     }
 
     target->resetIndexSource();
     return true;
 }