Return correctly mapped bounds from GrOvalRenderer.

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 "GrBatch.h"
@@ skipping 674 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 class CircleBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fInnerRadius;
         SkScalar fOuterRadius;
         bool fStroke;
-        SkRect fDevBounds;
+        SkRect fBounds;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(CircleBatch, (geometry));
     }
 
     const char* name() const override { return "CircleBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 62 matching lines @@
         }
 
         CircleVertex* verts = reinterpret_cast<CircleVertex*>(vertices);
 
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             SkScalar innerRadius = args.fInnerRadius;
             SkScalar outerRadius = args.fOuterRadius;
 
-            const SkRect& bounds = args.fDevBounds;
+            const SkRect& bounds = args.fBounds;
 
             // The inner radius in the vertex data must be specified in normalized space.
             innerRadius = innerRadius / outerRadius;
             verts[0].fPos = SkPoint::Make(bounds.fLeft,  bounds.fTop);
             verts[0].fOffset = SkPoint::Make(-1, -1);
             verts[0].fOuterRadius = outerRadius;
             verts[0].fInnerRadius = innerRadius;
 
             verts[1].fPos = SkPoint::Make(bounds.fLeft,  bounds.fBottom);
             verts[1].fOffset = SkPoint::Make(-1, 1);
@@ skipping 134 matching lines @@
         center.fX + outerRadius,
         center.fY + outerRadius
     );
 
     CircleBatch::Geometry geometry;
     geometry.fViewMatrix = viewMatrix;
     geometry.fColor = color;
     geometry.fInnerRadius = innerRadius;
     geometry.fOuterRadius = outerRadius;
     geometry.fStroke = isStrokeOnly && innerRadius > 0;
-    geometry.fDevBounds = bounds;
+    geometry.fBounds = bounds;
+
+    viewMatrix.mapRect(&bounds);
 
     SkAutoTUnref<GrBatch> batch(CircleBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch, &bounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class EllipseBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fXRadius;
         SkScalar fYRadius;
         SkScalar fInnerXRadius;
         SkScalar fInnerYRadius;
         bool fStroke;
-        SkRect fDevBounds;
+        SkRect fBounds;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(EllipseBatch, (geometry));
     }
 
     const char* name() const override { return "EllipseBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 67 matching lines @@
 
             SkScalar xRadius = args.fXRadius;
             SkScalar yRadius = args.fYRadius;
 
             // Compute the reciprocals of the radii here to save time in the shader
             SkScalar xRadRecip = SkScalarInvert(xRadius);
             SkScalar yRadRecip = SkScalarInvert(yRadius);
             SkScalar xInnerRadRecip = SkScalarInvert(args.fInnerXRadius);
             SkScalar yInnerRadRecip = SkScalarInvert(args.fInnerYRadius);
 
-            const SkRect& bounds = args.fDevBounds;
+            const SkRect& bounds = args.fBounds;
 
             // The inner radius in the vertex data must be specified in normalized space.
             verts[0].fPos = SkPoint::Make(bounds.fLeft,  bounds.fTop);
             verts[0].fOffset = SkPoint::Make(-xRadius, -yRadius);
             verts[0].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
             verts[0].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip);
 
             verts[1].fPos = SkPoint::Make(bounds.fLeft,  bounds.fBottom);
             verts[1].fOffset = SkPoint::Make(-xRadius, yRadius);
             verts[1].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip);
@@ skipping 170 matching lines @@
     );
 
     EllipseBatch::Geometry geometry;
     geometry.fViewMatrix = viewMatrix;
     geometry.fColor = color;
     geometry.fXRadius = xRadius;
     geometry.fYRadius = yRadius;
     geometry.fInnerXRadius = innerXRadius;
     geometry.fInnerYRadius = innerYRadius;
     geometry.fStroke = isStrokeOnly && innerXRadius > 0 && innerYRadius > 0;
-    geometry.fDevBounds = bounds;
+    geometry.fBounds = bounds;
+
+    viewMatrix.mapRect(&bounds);
 
     SkAutoTUnref<GrBatch> batch(EllipseBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch, &bounds);
 
     return true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 class DIEllipseBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fXRadius;
         SkScalar fYRadius;
         SkScalar fInnerXRadius;
         SkScalar fInnerYRadius;
         SkScalar fGeoDx;
         SkScalar fGeoDy;
         DIEllipseEdgeEffect::Mode fMode;
-        SkRect fDevBounds;
+        SkRect fBounds;
     };
 
     static GrBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(DIEllipseBatch, (geometry));
     }
 
     const char* name() const override { return "DIEllipseBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 56 matching lines @@
         }
 
         DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(vertices);
 
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             SkScalar xRadius = args.fXRadius;
             SkScalar yRadius = args.fYRadius;
 
-            const SkRect& bounds = args.fDevBounds;
+            const SkRect& bounds = args.fBounds;
 
             // This adjusts the "radius" to include the half-pixel border
             SkScalar offsetDx = SkScalarDiv(args.fGeoDx, xRadius);
             SkScalar offsetDy = SkScalarDiv(args.fGeoDy, yRadius);
 
             SkScalar innerRatioX = SkScalarDiv(xRadius, args.fInnerXRadius);
             SkScalar innerRatioY = SkScalarDiv(yRadius, args.fInnerYRadius);
 
             verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop);
             verts[0].fOuterOffset = SkPoint::Make(-1.0f - offsetDx, -1.0f - offsetDy);
@@ skipping 161 matching lines @@
     DIEllipseBatch::Geometry geometry;
     geometry.fViewMatrix = viewMatrix;
     geometry.fColor = color;
     geometry.fXRadius = xRadius;
     geometry.fYRadius = yRadius;
     geometry.fInnerXRadius = innerXRadius;
     geometry.fInnerYRadius = innerYRadius;
     geometry.fGeoDx = geoDx;
     geometry.fGeoDy = geoDy;
     geometry.fMode = mode;
-    geometry.fDevBounds = bounds;
+    geometry.fBounds = bounds;
+
+    viewMatrix.mapRect(&bounds);
 
     SkAutoTUnref<GrBatch> batch(DIEllipseBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch, &bounds);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const uint16_t gRRectIndices[] = {
@@ skipping 107 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class RRectCircleRendererBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fInnerRadius;
         SkScalar fOuterRadius;
         bool fStroke;
-        SkRect fDevBounds;
+        SkRect fBounds;
     };
 
     static GrBatch* Create(const Geometry& geometry, const GrIndexBuffer* indexBuffer) {
         return SkNEW_ARGS(RRectCircleRendererBatch, (geometry, indexBuffer));
     }
 
     const char* name() const override { return "RRectCircleBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 62 matching lines @@
             return;
         }
 
         CircleVertex* verts = reinterpret_cast<CircleVertex*>(vertices);
 
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             SkScalar outerRadius = args.fOuterRadius;
 
-            const SkRect& bounds = args.fDevBounds;
+            const SkRect& bounds = args.fBounds;
 
             SkScalar yCoords[4] = {
                 bounds.fTop,
                 bounds.fTop + outerRadius,
                 bounds.fBottom - outerRadius,
                 bounds.fBottom
             };
 
             SkScalar yOuterRadii[4] = {-1, 0, 0, 1 };
             // The inner radius in the vertex data must be specified in normalized space.
@@ skipping 105 matching lines @@
 class RRectEllipseRendererBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fXRadius;
         SkScalar fYRadius;
         SkScalar fInnerXRadius;
         SkScalar fInnerYRadius;
         bool fStroke;
-        SkRect fDevBounds;
+        SkRect fBounds;
     };
 
     static GrBatch* Create(const Geometry& geometry, const GrIndexBuffer* indexBuffer) {
         return SkNEW_ARGS(RRectEllipseRendererBatch, (geometry, indexBuffer));
     }
 
     const char* name() const override { return "RRectEllipseRendererBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
@@ skipping 70 matching lines @@
             // Compute the reciprocals of the radii here to save time in the shader
             SkScalar xRadRecip = SkScalarInvert(args.fXRadius);
             SkScalar yRadRecip = SkScalarInvert(args.fYRadius);
             SkScalar xInnerRadRecip = SkScalarInvert(args.fInnerXRadius);
             SkScalar yInnerRadRecip = SkScalarInvert(args.fInnerYRadius);
 
             // Extend the radii out half a pixel to antialias.
             SkScalar xOuterRadius = args.fXRadius + SK_ScalarHalf;
             SkScalar yOuterRadius = args.fYRadius + SK_ScalarHalf;
 
-            const SkRect& bounds = args.fDevBounds;
+            const SkRect& bounds = args.fBounds;
 
             SkScalar yCoords[4] = {
                 bounds.fTop,
                 bounds.fTop + yOuterRadius,
                 bounds.fBottom - yOuterRadius,
                 bounds.fBottom
             };
             SkScalar yOuterOffsets[4] = {
                 yOuterRadius,
                 SK_ScalarNearlyZero, // we're using inversesqrt() in shader, so can't be exactly 0
@@ skipping 211 matching lines @@
 
         // Expand the rect so all the pixels will be captured.
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
 
         RRectCircleRendererBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fInnerRadius = innerRadius;
         geometry.fOuterRadius = outerRadius;
         geometry.fStroke = isStrokeOnly;
-        geometry.fDevBounds = bounds;
+        geometry.fBounds = bounds;
+
+        viewMatrix.mapRect(&bounds);   
 
         SkAutoTUnref<GrBatch> batch(RRectCircleRendererBatch::Create(geometry, indexBuffer));
         target->drawBatch(pipelineBuilder, batch, &bounds);
 
     // otherwise we use the ellipse renderer
     } else {
         SkScalar innerXRadius = 0.0f;
         SkScalar innerYRadius = 0.0f;
         if (hasStroke) {
             if (SkScalarNearlyZero(scaledStroke.length())) {
@@ skipping 31 matching lines @@
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
 
         RRectEllipseRendererBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fXRadius = xRadius;
         geometry.fYRadius = yRadius;
         geometry.fInnerXRadius = innerXRadius;
         geometry.fInnerYRadius = innerYRadius;
         geometry.fStroke = isStrokeOnly;
-        geometry.fDevBounds = bounds;
+        geometry.fBounds = bounds;
+
+        viewMatrix.mapRect(&bounds);   
 
         SkAutoTUnref<GrBatch> batch(RRectEllipseRendererBatch::Create(geometry, indexBuffer));
         target->drawBatch(pipelineBuilder, batch, &bounds);
     }
     return true;
 }