Move bounds to GrBatch

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
@@ skipping 607 matching lines @@
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     StrokeRectBatch(const Geometry& geometry) {
         this->initClassID<StrokeRectBatch>();
 
         fBatch.fHairline = geometry.fStrokeWidth == 0;
 
         fGeoData.push_back(geometry);
+
+        // setup bounds
+        this->setBounds(geometry.fRect);
+        SkScalar rad = SkScalarHalf(geometry.fStrokeWidth);
+        this->getBounds()->outset(rad, rad);
+        geometry.fViewMatrix.mapRect(this->getBounds());
     }
 
     /*  create a triangle strip that strokes the specified rect. There are 8
      unique vertices, but we repeat the last 2 to close up. Alternatively we
      could use an indices array, and then only send 8 verts, but not sure that
      would be faster.
      */
     void setStrokeRectStrip(SkPoint verts[10], const SkRect& rect, SkScalar width) {
         const SkScalar rad = SkScalarHalf(width);
         // TODO we should be able to enable this assert, but we'd have to filter these draws
@@ skipping 130 matching lines @@
 
     if (width >= 0) {
         StrokeRectBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fRect = rect;
         geometry.fStrokeWidth = width;
 
         SkAutoTUnref<GrBatch> batch(StrokeRectBatch::Create(geometry));
 
-        SkRect bounds = rect;
-        SkScalar rad = SkScalarHalf(width);
-        bounds.outset(rad, rad);
-        viewMatrix.mapRect(&bounds);
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  0 == width && !rt->isMultisampled());
-        target->drawBatch(&pipelineBuilder, batch, &bounds);
+        target->drawBatch(&pipelineBuilder, batch);
     } else {
         // filled BW rect
         target->drawSimpleRect(&pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
 void GrContext::drawNonAARectToRect(GrRenderTarget* rt,
                                     const GrClip& clip,
                                     const GrPaint& paint,
                                     const SkMatrix& viewMatrix,
@@ skipping 217 matching lines @@
 
         if (localCoords) {
             installedGeo.fLocalCoords.append(vertexCount, localCoords);
             fBatch.fHasLocalCoords = true;
         } else {
             fBatch.fHasLocalCoords = false;
         }
         fBatch.fVertexCount = vertexCount;
         fBatch.fIndexCount = indexCount;
         fBatch.fPrimitiveType = primitiveType;
+
+        // TODO figure out bounds
+        this->setBoundsLargest();
     }
 
     GrPrimitiveType primitiveType() const { return fBatch.fPrimitiveType; }
     bool batchablePrimitiveType() const {
         return kTriangles_GrPrimitiveType == fBatch.fPrimitiveType ||
                kLines_GrPrimitiveType == fBatch.fPrimitiveType ||
                kPoints_GrPrimitiveType == fBatch.fPrimitiveType;
     }
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
@@ skipping 34 matching lines @@
         if (!this->hasColors() && this->color() != that->color()) {
             return false;
         }
 
         if (this->color() != that->color()) {
             fBatch.fColor = GrColor_ILLEGAL;
         }
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         fBatch.fVertexCount += that->vertexCount();
         fBatch.fIndexCount += that->indexCount();
+
+        this->joinBounds(that->bounds());
         return true;
     }
 
     struct BatchTracker {
         GrPrimitiveType fPrimitiveType;
         SkMatrix fViewMatrix;
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
@@ skipping 30 matching lines @@
 
     GR_CREATE_TRACE_MARKER("GrContext::drawVertices", target);
 
     DrawVerticesBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
 
     SkAutoTUnref<GrBatch> batch(DrawVerticesBatch::Create(geometry, primitiveType, viewMatrix,
                                                           positions, vertexCount, indices,
                                                           indexCount,colors, texCoords));
 
-    // TODO figure out bounds
-    target->drawBatch(&pipelineBuilder, batch, NULL);
+    target->drawBatch(&pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawRRect(GrRenderTarget*rt,
                           const GrClip& clip,
                           const GrPaint& paint,
                           const SkMatrix& viewMatrix,
                           const SkRRect& rrect,
                           const GrStrokeInfo& strokeInfo) {
@@ skipping 867 matching lines @@
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }