Remove coordchanges from 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 47 matching lines @@
  * with origin at the circle center. Two   vertex attributes are used:
  *    vec2f : position in device space of the bounding geometry vertices
  *    vec4f : (p.xy, outerRad, innerRad)
  *             p is the position in the normalized space.
  *             outerRad is the outerRadius in device space.
  *             innerRad is the innerRadius in normalized space (ignored if not stroking).
  */
 
 class CircleEdgeEffect : public GrGeometryProcessor {
 public:
-    static GrGeometryProcessor* Create(GrColor color, bool stroke) {
-        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(CircleEdgeEffect, (color, stroke, localMatrix));
     }
 
     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 87 matching lines @@
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
-    CircleEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
+    CircleEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
+        : INHERITED(color, false, localMatrix) {
         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 17 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(GrRandomColor(random), random->nextBool());
+    return CircleEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+                                    GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * 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(GrColor color, bool stroke) {
-        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke));
+    static GrGeometryProcessor* Create(GrColor color, bool stroke, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(EllipseEdgeEffect, (color, stroke, localMatrix));
     }
 
     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 111 matching lines @@
                         const GrBatchTracker& t) const SK_OVERRIDE {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor);
     }
 
 private:
-    EllipseEdgeEffect(GrColor color, bool stroke) : INHERITED(color) {
+    EllipseEdgeEffect(GrColor color, bool stroke, const SkMatrix& localMatrix)
+        : INHERITED(color, false, localMatrix) {
         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 20 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(GrRandomColor(random), random->nextBool());
+    return EllipseEdgeEffect::Create(GrRandomColor(random), random->nextBool(),
+                                     GrProcessorUnitTest::TestMatrix(random));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * 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.
  *
@@ skipping 245 matching lines @@
                                 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());
 
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
         return;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkStrokeRec::Style style = stroke.getStyle();
     bool isStrokeOnly = SkStrokeRec::kStroke_Style == style ||
                         SkStrokeRec::kHairline_Style == style;
     bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == style;
 
     SkScalar innerRadius = 0.0f;
     SkScalar outerRadius = radius;
     SkScalar halfWidth = 0;
     if (hasStroke) {
         if (SkScalarNearlyZero(strokeWidth)) {
             halfWidth = SK_ScalarHalf;
         } else {
             halfWidth = SkScalarHalf(strokeWidth);
         }
 
         outerRadius += halfWidth;
         if (isStrokeOnly) {
             innerRadius = radius - halfWidth;
         }
     }
 
     SkAutoTUnref<GrGeometryProcessor> gp(
-            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0));
+            CircleEdgeEffect::Create(color, isStrokeOnly && innerRadius > 0, invert));
 
     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 101 matching lines @@
         // this is legit only if scale & translation (which should be the case at the moment)
         if (isStrokeOnly) {
             innerXRadius = xRadius - scaledStroke.fX;
             innerYRadius = yRadius - scaledStroke.fY;
         }
 
         xRadius += scaledStroke.fX;
         yRadius += scaledStroke.fY;
     }
 
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
         return false;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     SkAutoTUnref<GrGeometryProcessor> gp(
-            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0));
+            EllipseEdgeEffect::Create(color, isStrokeOnly && innerXRadius > 0 && innerYRadius > 0,
+                                      invert));
 
     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 241 matching lines @@
     }
     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)) {
+
+    SkMatrix invert;
+    if (!drawState->getViewMatrix().invert(&invert)) {
         return false;
     }
+
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
     drawState->addCoverageProcessor(effect)->unref();
     SkRect bounds = outer->getBounds();
     if (applyAA) {
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
     }
-    target->drawSimpleRect(drawState, color, bounds);
+    target->drawRect(drawState, color, bounds, NULL, &invert);
     return true;
 }
 
 bool GrOvalRenderer::drawRRect(GrDrawTarget* target,
                                GrDrawState* drawState,
                                GrColor color,
                                bool useAA,
                                const SkRRect& rrect,
                                const SkStrokeRec& stroke) {
     if (rrect.isOval()) {
@@ skipping 55 matching lines @@
     // The way the effect interpolates the offset-to-ellipse/circle-center attribute only works on
     // the interior of the rrect if the radii are >= 0.5. Otherwise, the inner rect of the nine-
     // patch will have fractional coverage. This only matters when the interior is actually filled.
     // We could consider falling back to rect rendering here, since a tiny radius is
     // indistinguishable from a square corner.
     if (!isStrokeOnly && (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) {
         return false;
     }
 
     // reset to device coordinates
-    GrDrawState::AutoViewMatrixRestore avmr;
-    if (!avmr.setIdentity(drawState)) {
+    SkMatrix invert;
+    if (!vm.invert(&invert)) {
+        SkDebugf("Failed to invert\n");
         return false;
     }
 
+    GrDrawState::AutoViewMatrixRestore avmr(drawState);
+
     GrIndexBuffer* indexBuffer = this->rRectIndexBuffer(isStrokeOnly);
     if (NULL == indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
         return false;
     }
 
     // if the corners are circles, use the circle renderer
     if ((!hasStroke || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) {
         SkScalar innerRadius = 0.0f;
         SkScalar outerRadius = xRadius;
         SkScalar halfWidth = 0;
         if (hasStroke) {
             if (SkScalarNearlyZero(scaledStroke.fX)) {
                 halfWidth = SK_ScalarHalf;
             } else {
                 halfWidth = SkScalarHalf(scaledStroke.fX);
             }
 
             if (isStrokeOnly) {
                 innerRadius = xRadius - halfWidth;
             }
             outerRadius += halfWidth;
             bounds.outset(halfWidth, halfWidth);
         }
 
         isStrokeOnly = (isStrokeOnly && innerRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly));
+        SkAutoTUnref<GrGeometryProcessor> effect(CircleEdgeEffect::Create(color, isStrokeOnly,
+                                                                          invert));
 
         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 78 matching lines @@
                 innerYRadius = yRadius - scaledStroke.fY;
             }
 
             xRadius += scaledStroke.fX;
             yRadius += scaledStroke.fY;
             bounds.outset(scaledStroke.fX, scaledStroke.fY);
         }
 
         isStrokeOnly = (isStrokeOnly && innerXRadius >= 0 && innerYRadius >= 0);
 
-        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly));
+        SkAutoTUnref<GrGeometryProcessor> effect(EllipseEdgeEffect::Create(color, isStrokeOnly,
+                                                                           invert));
 
         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 53 matching lines @@
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexedInstances(drawState, effect, kTriangles_GrPrimitiveType, 1, 16, indexCnt,
                                      &bounds);
     }
 
     target->resetIndexSource();
     return true;
 }