Initial CL to move color / coverage off of drawstate

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 41 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for a circle,
  * specified as offset_x, offset_y (both from center point), outer radius and inner radius.
  */
 
 class CircleEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(bool stroke) {
-        return SkNEW_ARGS(CircleEdgeEffect, (stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke) {
+        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke));
     }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inCircleEdge() const { return fInCircleEdge; }
     virtual ~CircleEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "CircleEdge"; }
 
     inline bool isStroked() const { return fStroke; }
 
@@ skipping 50 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    CircleEdgeEffect(bool stroke) {
+    CircleEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
         this->initClassID<CircleEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         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;
@@ skipping 11 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleEdgeEffect);
 
 GrGeometryProcessor* CircleEdgeEffect::TestCreate(SkRandom* random,
                                                   GrContext* context,
                                                   const GrDrawTargetCaps&,
                                                   GrTexture* textures[]) {
-    return CircleEdgeEffect::Create(random->nextBool());
+    return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for an axis-aligned
  * ellipse, specified as a 2D offset from center, and the reciprocals of the outer and inner radii,
  * in both x and y directions.
  *
  * We are using an implicit function of x^2/a^2 + y^2/b^2 - 1 = 0.
  */
 
 class EllipseEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(bool stroke) {
-        return SkNEW_ARGS(EllipseEdgeEffect, (stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke) {
+        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke));
     }
 
     virtual ~EllipseEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "EllipseEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inEllipseOffset() const { return fInEllipseOffset; }
     const GrAttribute* inEllipseRadii() const { return fInEllipseRadii; }
 
@@ skipping 75 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    EllipseEdgeEffect(bool stroke) {
+    EllipseEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
         this->initClassID<EllipseEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInEllipseOffset = &this->addVertexAttrib(GrAttribute("inEllipseOffset",
                                                               kVec2f_GrVertexAttribType));
         fInEllipseRadii = &this->addVertexAttrib(GrAttribute("inEllipseRadii",
                                                              kVec4f_GrVertexAttribType));
         fStroke = stroke;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
@@ skipping 14 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseEdgeEffect);
 
 GrGeometryProcessor* EllipseEdgeEffect::TestCreate(SkRandom* random,
                                                    GrContext* context,
                                                    const GrDrawTargetCaps&,
                                                    GrTexture* textures[]) {
-    return EllipseEdgeEffect::Create(random->nextBool());
+    return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for an ellipse,
  * specified as a 2D offset from center for both the outer and inner paths (if stroked). The
  * implict equation used is for a unit circle (x^2 + y^2 - 1 = 0) and the edge corrected by
  * using differentials.
  *
  * The result is device-independent and can be used with any affine matrix.
  */
 
 class DIEllipseEdgeEffect : public GrGeometryProcessor {
 public:
     enum Mode { kStroke = 0, kHairline, kFill };
 
-    static GrGeometryProcessor* Create(Mode mode) {
-        return SkNEW_ARGS(DIEllipseEdgeEffect, (mode));
+    static GrGeometryProcessor* Create(GrColor color, Mode mode) {
+        return SkNEW_ARGS(DIEllipseEdgeEffect, (color, mode));
     }
 
     virtual ~DIEllipseEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "DIEllipseEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inEllipseOffsets0() const { return fInEllipseOffsets0; }
     const GrAttribute* inEllipseOffsets1() const { return fInEllipseOffsets1; }
 
@@ skipping 90 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    DIEllipseEdgeEffect(Mode mode) {
+    DIEllipseEdgeEffect(GrColor color, Mode mode) : INHERITED(color) {
         this->initClassID<DIEllipseEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInEllipseOffsets0 = &this->addVertexAttrib(GrAttribute("inEllipseOffsets0",
                                                                 kVec2f_GrVertexAttribType));
         fInEllipseOffsets1 = &this->addVertexAttrib(GrAttribute("inEllipseOffsets1",
                                                                 kVec2f_GrVertexAttribType));
         fMode = mode;
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
@@ skipping 14 matching lines @@
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseEdgeEffect);
 
 GrGeometryProcessor* DIEllipseEdgeEffect::TestCreate(SkRandom* random,
                                                      GrContext* context,
                                                      const GrDrawTargetCaps&,
                                                      GrTexture* textures[]) {
-    return DIEllipseEdgeEffect::Create((Mode)(random->nextRangeU(0,2)));
+    return DIEllipseEdgeEffect::Create(GrRandomColor(random), (Mode)(random->nextRangeU(0,2)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::reset() {
     SkSafeSetNull(fRRectIndexBuffer);
     SkSafeSetNull(fStrokeRRectIndexBuffer);
 }
 
 bool GrOvalRenderer::drawOval(GrDrawTarget* target,
                               GrDrawState* drawState,
+                              GrColor color,
                               const GrContext* context,
                               bool useAA,
                               const SkRect& oval,
                               const SkStrokeRec& stroke)
 {
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
-        drawState->couldApplyCoverage(*target->caps());
+        drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     if (!useCoverageAA) {
         return false;
     }
 
     const SkMatrix& vm = context->getMatrix();
 
     // we can draw circles
     if (SkScalarNearlyEqual(oval.width(), oval.height())
         && circle_stays_circle(vm)) {
-        this->drawCircle(target, drawState, context, useCoverageAA, oval, stroke);
+        this->drawCircle(target, drawState, color, context, useCoverageAA, oval, stroke);
     // if we have shader derivative support, render as device-independent
     } else if (target->caps()->shaderDerivativeSupport()) {
-        return this->drawDIEllipse(target, drawState, context, useCoverageAA, oval, stroke);
+        return this->drawDIEllipse(target, drawState, color, context, useCoverageAA, oval, stroke);
     // otherwise axis-aligned ellipses only
     } else if (vm.rectStaysRect()) {
-        return this->drawEllipse(target, drawState, context, useCoverageAA, oval, stroke);
+        return this->drawEllipse(target, drawState, color, context, useCoverageAA, oval, stroke);
     } else {
         return false;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrOvalRenderer::drawCircle(GrDrawTarget* target,
                                 GrDrawState* drawState,
+                                GrColor color,
                                 const GrContext* context,
                                 bool useCoverageAA,
                                 const SkRect& circle,
                                 const SkStrokeRec& stroke)
 {
     const SkMatrix& vm = drawState->getViewMatrix();
     SkPoint center = SkPoint::Make(circle.centerX(), circle.centerY());
     vm.mapPoints(&center, 1);
     SkScalar radius = vm.mapRadius(SkScalarHalf(circle.width()));
     SkScalar strokeWidth = vm.mapRadius(stroke.getWidth());
@@ skipping 17 matching lines @@
         } else {
             halfWidth = SkScalarHalf(strokeWidth);
         }
 
         outerRadius += halfWidth;
         if (isStrokeOnly) {
             innerRadius = radius - halfWidth;
         }
     }
 
-    GrGeometryProcessor* gp = CircleEdgeEffect::Create(isStrokeOnly && innerRadius > 0);
+    GrGeometryProcessor* gp = CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0);
     drawState->setGeometryProcessor(gp)->unref();
 
     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 34 matching lines @@
 
     target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
                                  GrDrawState* drawState,
+                                 GrColor color,
                                  const GrContext* context,
                                  bool useCoverageAA,
                                  const SkRect& ellipse,
                                  const SkStrokeRec& stroke)
 {
 #ifdef SK_DEBUG
     {
         // we should have checked for this previously
         bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect();
         SkASSERT(useCoverageAA && isAxisAlignedEllipse);
@@ skipping 51 matching lines @@
 
         xRadius += scaledStroke.fX;
         yRadius += scaledStroke.fY;
     }
 
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return false;
     }
 
-    GrGeometryProcessor* gp = EllipseEdgeEffect::Create(isStrokeOnly &&
+    GrGeometryProcessor* gp = EllipseEdgeEffect::Create(color,
+                                                        isStrokeOnly &&
                                                         innerXRadius > 0 && innerYRadius > 0);
 
     drawState->setGeometryProcessor(gp)->unref();
 
     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;
     }
@@ skipping 41 matching lines @@
 
     target->setIndexSourceToBuffer(context->getGpu()->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &bounds);
     target->resetIndexSource();
 
     return true;
 }
 
 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target,
                                    GrDrawState* drawState,
+                                   GrColor color,
                                    const GrContext* context,
                                    bool useCoverageAA,
                                    const SkRect& ellipse,
                                    const SkStrokeRec& stroke)
 {
     const SkMatrix& vm = drawState->getViewMatrix();
 
     SkPoint center = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
     SkScalar xRadius = SkScalarHalf(ellipse.width());
     SkScalar yRadius = SkScalarHalf(ellipse.height());
@@ skipping 36 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(mode);
+    GrGeometryProcessor* gp = DIEllipseEdgeEffect::Create(color, mode);
 
     drawState->setGeometryProcessor(gp)->unref();
 
     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;
     }
 
@@ skipping 80 matching lines @@
                                                                 kIndicesPerRRect,
                                                                 kNumRRectsInIndexBuffer,
                                                                 kVertsPerRRect);
         }
         return fRRectIndexBuffer;
     }
 }
 
 bool GrOvalRenderer::drawDRRect(GrDrawTarget* target,
                                 GrDrawState* drawState,
+                                GrColor color,
                                 GrContext* context,
                                 bool useAA,
                                 const SkRRect& origOuter,
                                 const SkRRect& origInner) {
     bool applyAA = useAA &&
                    !drawState->getRenderTarget()->isMultisampled() &&
-                   drawState->couldApplyCoverage(*target->caps());
+                   drawState->canUseFracCoveragePrimProc(color, *target->caps());
     GrDrawState::AutoRestoreEffects are;
     if (!origInner.isEmpty()) {
         SkTCopyOnFirstWrite<SkRRect> inner(origInner);
         if (!context->getMatrix().isIdentity()) {
             if (!origInner.transform(context->getMatrix(), inner.writable())) {
                 return false;
             }
         }
         GrPrimitiveEdgeType edgeType = applyAA ?
                 kInverseFillAA_GrProcessorEdgeType :
                 kInverseFillBW_GrProcessorEdgeType;
+        // TODO this needs to be a geometry processor
         GrFragmentProcessor* fp = GrRRectEffect::Create(edgeType, *inner);
         if (NULL == fp) {
             return false;
         }
         are.set(drawState);
         drawState->addCoverageProcessor(fp)->unref();
     }
 
     SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
-    if (this->drawRRect(target, drawState, context, useAA, origOuter, fillRec)) {
+    if (this->drawRRect(target, drawState, color, context, useAA, origOuter, fillRec)) {
         return true;
     }
 
     SkASSERT(!origOuter.isEmpty());
     SkTCopyOnFirstWrite<SkRRect> outer(origOuter);
     if (!context->getMatrix().isIdentity()) {
         if (!origOuter.transform(context->getMatrix(), outer.writable())) {
             return false;
         }
     }
     GrPrimitiveEdgeType edgeType = applyAA ? kFillAA_GrProcessorEdgeType :
                                           kFillBW_GrProcessorEdgeType;
     GrFragmentProcessor* effect = GrRRectEffect::Create(edgeType, *outer);
     if (NULL == effect) {
         return false;
     }
     if (!are.isSet()) {
         are.set(drawState);
     }
     GrDrawState::AutoViewMatrixRestore avmr;
     if (!avmr.setIdentity(drawState)) {
         return false;
     }
     drawState->addCoverageProcessor(effect)->unref();
     SkRect bounds = outer->getBounds();
     if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
-    target->drawRect(drawState, bounds, NULL, NULL);
+    target->drawRect(drawState, color, bounds, NULL, NULL);
     return true;
 }
 
 bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
                                GrDrawState* drawState,
+                               GrColor color,
                                GrContext* context,
                                bool useAA,
                                const SkRRect& rrect,
                                const SkStrokeRec& stroke) {
     if (rrect.isOval()) {
-        return this->drawOval(target, drawState, context, useAA, rrect.getBounds(), stroke);
+        return this->drawOval(target, drawState, color, context, useAA, rrect.getBounds(), stroke);
     }
 
     bool useCoverageAA = useAA &&
         !drawState->getRenderTarget()->isMultisampled() &&
-        drawState->couldApplyCoverage(*target->caps());
+        drawState->canUseFracCoveragePrimProc(color, *target->caps());
 
     // only anti-aliased rrects for now
     if (!useCoverageAA) {
         return false;
     }
 
     const SkMatrix& vm = context->getMatrix();
 
     if (!vm.rectStaysRect() || !rrect.isSimple()) {
         return false;
@@ skipping 71 matching lines @@
 
             if (isStrokeOnly) {
                 innerRadius = xRadius - halfWidth;
             }
             outerRadius += halfWidth;
             bounds.outset(halfWidth, halfWidth);
         }
 
         isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
 
-        GrGeometryProcessor* effect = CircleEdgeEffect::Create(isStrokeOnly);
+        GrGeometryProcessor* effect = CircleEdgeEffect::Create(color, isStrokeOnly);
         drawState->setGeometryProcessor(effect)->unref();
 
         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());
 
@@ skipping 81 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(isStrokeOnly);
+        GrGeometryProcessor* effect = EllipseEdgeEffect::Create(color, isStrokeOnly);
         drawState->setGeometryProcessor(effect)->unref();
 
         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 54 matching lines @@
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
     }
 
     target->resetIndexSource();
     return true;
 }