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 511 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
+        fBounds = geometry.fRect;
+        SkScalar rad = SkScalarHalf(geometry.fStrokeWidth);
+        fBounds.outset(rad, rad);
+        geometry.fViewMatrix.mapRect(&fBounds);
     }
 
     /*  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 49 matching lines @@
         SkTDArray<SkPoint> fPositions;
         SkTDArray<uint16_t> fIndices;
         SkTDArray<GrColor> fColors;
         SkTDArray<SkPoint> fLocalCoords;
     };
 
     static GrBatch* Create(const Geometry& geometry, GrPrimitiveType primitiveType,
                            const SkMatrix& viewMatrix,
                            const SkPoint* positions, int vertexCount,
                            const uint16_t* indices, int indexCount,
-                           const GrColor* colors, const SkPoint* localCoords) {
+                           const GrColor* colors, const SkPoint* localCoords,
+                           const SkRect& bounds) {
         return SkNEW_ARGS(DrawVerticesBatch, (geometry, primitiveType, viewMatrix, positions,
                                               vertexCount, indices, indexCount, colors,
-                                              localCoords));
+                                              localCoords, bounds));
     }
 
     const char* name() const override { return "DrawVerticesBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         if (this->hasColors()) {
             out->setUnknownFourComponents();
         } else {
             out->setKnownFourComponents(fGeoData[0].fColor);
@@ skipping 113 matching lines @@
         batchTarget->draw(drawInfo);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     DrawVerticesBatch(const Geometry& geometry, GrPrimitiveType primitiveType,
                       const SkMatrix& viewMatrix,
                       const SkPoint* positions, int vertexCount,
                       const uint16_t* indices, int indexCount,
-                      const GrColor* colors, const SkPoint* localCoords) {
+                      const GrColor* colors, const SkPoint* localCoords, const SkRect& bounds) {
         this->initClassID<DrawVerticesBatch>();
         SkASSERT(positions);
 
         fBatch.fViewMatrix = viewMatrix;
         Geometry& installedGeo = fGeoData.push_back(geometry);
 
         installedGeo.fPositions.append(vertexCount, positions);
         if (indices) {
             installedGeo.fIndices.append(indexCount, indices);
             fBatch.fHasIndices = true;
@@ skipping 10 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;
+
+        this->setBounds(bounds);
     }
 
     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 32 matching lines @@
 
     // TODO clients should give us bounds
     SkRect bounds;
     if (!bounds.setBoundsCheck(positions, vertexCount)) {
         SkDebugf("drawVertices call empty bounds\n");
         return;
     }
 
     DrawVerticesBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
-
     SkAutoTUnref<GrBatch> batch(DrawVerticesBatch::Create(geometry, primitiveType, viewMatrix,
                                                           positions, vertexCount, indices,
-                                                          indexCount,colors, texCoords));
+                                                          indexCount, colors, texCoords,
+                                                          bounds));
 
-    // TODO figure out bounds
-    target->drawBatch(&pipelineBuilder, batch, &bounds);
+    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 851 matching lines @@
         fDrawBuffer->addGpuTraceMarker(marker);
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }