Move bounds to GrBatch

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 818 matching lines @@
             instanceCount -= drawInfo.instanceCount();
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     CircleBatch(const Geometry& geometry) {
         this->initClassID<CircleBatch>();
         fGeoData.push_back(geometry);
+
+        this->setBounds(geometry.fDevBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         CircleBatch* that = t->cast<CircleBatch>();
 
         // TODO use vertex color to avoid breaking batches
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->stroke() != that->stroke()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool stroke() const { return fBatch.fStroke; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 66 matching lines @@
 void GrOvalRenderer::drawCircle(GrDrawTarget* target,
                                 GrPipelineBuilder* pipelineBuilder,
                                 GrColor color,
                                 const SkMatrix& viewMatrix,
                                 bool useCoverageAA,
                                 const SkRect& circle,
                                 const SkStrokeRec& stroke) {
     SkRect bounds;
     SkAutoTUnref<GrBatch> batch(create_circle_batch(color, viewMatrix, useCoverageAA, circle,
                                                     stroke, &bounds));
-    target->drawBatch(pipelineBuilder, batch, &bounds);
+    target->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class EllipseBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkScalar fXRadius;
@@ skipping 140 matching lines @@
             instanceCount -= drawInfo.instanceCount();
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     EllipseBatch(const Geometry& geometry) {
         this->initClassID<EllipseBatch>();
         fGeoData.push_back(geometry);
+
+        this->setBounds(geometry.fDevBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         EllipseBatch* that = t->cast<EllipseBatch>();
 
         // TODO use vertex color to avoid breaking batches
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->stroke() != that->stroke()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool stroke() const { return fBatch.fStroke; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 107 matching lines @@
                                  bool useCoverageAA,
                                  const SkRect& ellipse,
                                  const SkStrokeRec& stroke) {
     SkRect bounds;
     SkAutoTUnref<GrBatch> batch(create_ellipse_batch(color, viewMatrix, useCoverageAA, ellipse,
                                                      stroke, &bounds));
     if (!batch) {
         return false;
     }
 
-    target->drawBatch(pipelineBuilder, batch, &bounds);
+    target->drawBatch(pipelineBuilder, batch);
     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 fBounds;
     };
 
-    static GrBatch* Create(const Geometry& geometry) {
-        return SkNEW_ARGS(DIEllipseBatch, (geometry));
+    static GrBatch* Create(const Geometry& geometry, const SkRect& bounds) {
+        return SkNEW_ARGS(DIEllipseBatch, (geometry, bounds));
     }
 
     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
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
@@ skipping 109 matching lines @@
             batchTarget->draw(drawInfo);
 
             drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
             instanceCount -= drawInfo.instanceCount();
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
-    DIEllipseBatch(const Geometry& geometry) {
+    DIEllipseBatch(const Geometry& geometry, const SkRect& bounds) {
         this->initClassID<DIEllipseBatch>();
         fGeoData.push_back(geometry);
+
+        this->setBounds(bounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         DIEllipseBatch* that = t->cast<DIEllipseBatch>();
 
         // TODO use vertex color to avoid breaking batches
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->mode() != that->mode()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     DIEllipseEdgeEffect::Mode mode() const { return fBatch.fMode; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 80 matching lines @@
     geometry.fXRadius = xRadius;
     geometry.fYRadius = yRadius;
     geometry.fInnerXRadius = innerXRadius;
     geometry.fInnerYRadius = innerYRadius;
     geometry.fGeoDx = geoDx;
     geometry.fGeoDy = geoDy;
     geometry.fMode = mode;
     geometry.fBounds = *bounds;
 
     viewMatrix.mapRect(bounds);
-    return DIEllipseBatch::Create(geometry);
+    return DIEllipseBatch::Create(geometry, *bounds);
 }
 
 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target,
                                    GrPipelineBuilder* pipelineBuilder,
                                    GrColor color,
                                    const SkMatrix& viewMatrix,
                                    bool useCoverageAA,
                                    const SkRect& ellipse,
                                    const SkStrokeRec& stroke) {
     SkRect bounds;
     SkAutoTUnref<GrBatch> batch(create_diellipse_batch(color, viewMatrix, useCoverageAA, ellipse,
                                                        stroke, &bounds));
     if (!batch) {
         return false;
     }
-    target->drawBatch(pipelineBuilder, batch, &bounds);
+    target->drawBatch(pipelineBuilder, batch);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static const uint16_t gRRectIndices[] = {
     // corners
     0, 1, 5, 0, 5, 4,
     2, 3, 7, 2, 7, 6,
     8, 9, 13, 8, 13, 12,
@@ skipping 241 matching lines @@
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     RRectCircleRendererBatch(const Geometry& geometry, const GrIndexBuffer* indexBuffer)
         : fIndexBuffer(indexBuffer) {
         this->initClassID<RRectCircleRendererBatch>();
         fGeoData.push_back(geometry);
+
+        this->setBounds(geometry.fDevBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         RRectCircleRendererBatch* that = t->cast<RRectCircleRendererBatch>();
 
         // TODO use vertex color to avoid breaking batches
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->stroke() != that->stroke()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool stroke() const { return fBatch.fStroke; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 179 matching lines @@
         }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     RRectEllipseRendererBatch(const Geometry& geometry, const GrIndexBuffer* indexBuffer)
         : fIndexBuffer(indexBuffer) {
         this->initClassID<RRectEllipseRendererBatch>();
         fGeoData.push_back(geometry);
+
+        this->setBounds(geometry.fDevBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         RRectEllipseRendererBatch* that = t->cast<RRectEllipseRendererBatch>();
 
         // TODO use vertex color to avoid breaking batches
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->stroke() != that->stroke()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool stroke() const { return fBatch.fStroke; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 217 matching lines @@
     }
 
     SkRect bounds;
     SkAutoTUnref<GrBatch> batch(create_rrect_batch(color, viewMatrix, rrect, stroke, &bounds,
                                                    &fStrokeRRectIndexBuffer, &fRRectIndexBuffer,
                                                    fGpu));
     if (!batch) {
         return false;
     }
 
-    target->drawBatch(pipelineBuilder, batch, &bounds);
+    target->drawBatch(pipelineBuilder, batch);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 static SkStrokeRec random_strokerec(SkRandom* random) {
     SkStrokeRec::InitStyle style =
             SkStrokeRec::InitStyle(random->nextULessThan(SkStrokeRec::kFill_InitStyle + 1));
@@ skipping 40 matching lines @@
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
 
     static GrIndexBuffer* gStrokeRRectIndexBuffer;
     static GrIndexBuffer* gRRectIndexBuffer;
     SkRect bounds;
     return create_rrect_batch(color, viewMatrix, rrect, random_strokerec(random), &bounds,
                               &gStrokeRRectIndexBuffer, &gRRectIndexBuffer, context->getGpu());
 }
 
 #endif