fix bounds for BW lines, AA Hairlines

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 386 matching lines @@
 
 class StrokeRectBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkScalar fStrokeWidth;
     };
 
-    static GrBatch* Create(const Geometry& geometry) {
-        return SkNEW_ARGS(StrokeRectBatch, (geometry));
+    static GrBatch* Create(const Geometry& geometry, bool snapToPixelCenters) {
+        return SkNEW_ARGS(StrokeRectBatch, (geometry, snapToPixelCenters));
     }
 
     const char* name() const override { return "StrokeRectBatch"; }
 
     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 {
@@ skipping 75 matching lines @@
         }
 
         GrVertices vertices;
         vertices.init(primType, vertexBuffer, firstVertex, vertexCount);
         batchTarget->draw(vertices);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
-    StrokeRectBatch(const Geometry& geometry) {
+    StrokeRectBatch(const Geometry& geometry, bool snapToPixelCenters) {
         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);
+
+        // If our caller snaps to pixel centers then we have to round out the bounds
+        if (snapToPixelCenters) {
+            fBounds.roundOut();
+        }
     }
 
     /*  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 128 matching lines @@
         return;
     }
 
     if (width >= 0) {
         StrokeRectBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fRect = rect;
         geometry.fStrokeWidth = width;
 
-        SkAutoTUnref<GrBatch> batch(StrokeRectBatch::Create(geometry));
+        // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
+        bool snapToPixelCenters = (0 == width && !rt->isMultisampled());
+        SkAutoTUnref<GrBatch> batch(StrokeRectBatch::Create(geometry, snapToPixelCenters));
 
         // 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());
+                                 snapToPixelCenters);
         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,
@@ skipping 320 matching lines @@
 
     // TODO clients should give us bounds
     SkRect bounds;
     if (!bounds.setBoundsCheck(positions, vertexCount)) {
         SkDebugf("drawVertices call empty bounds\n");
         return;
     }
 
     viewMatrix.mapRect(&bounds);
 
+    // If we don't have AA then we outset for a half pixel in each direction to account for
+    // snapping
+    if (!paint.isAntiAlias()) {
+        bounds.outset(0.5f, 0.5f);
+    }
+
     DrawVerticesBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrBatch> batch(DrawVerticesBatch::Create(geometry, primitiveType, viewMatrix,
                                                           positions, vertexCount, indices,
                                                           indexCount, colors, texCoords,
                                                           bounds));
 
     target->drawBatch(&pipelineBuilder, batch);
 }
 
@@ skipping 851 matching lines @@
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(StrokeRect) {
     StrokeRectBatch::Geometry geometry;
     geometry.fViewMatrix = GrTest::TestMatrix(random);
     geometry.fColor = GrRandomColor(random);
     geometry.fRect = GrTest::TestRect(random);
     geometry.fStrokeWidth = random->nextBool() ? 0.0f : 1.0f;
 
-    return StrokeRectBatch::Create(geometry);
+    return StrokeRectBatch::Create(geometry, random->nextBool());
 }
 
 static uint32_t seed_vertices(GrPrimitiveType type) {
     switch (type) {
         case kTriangles_GrPrimitiveType:
         case kTriangleStrip_GrPrimitiveType:
         case kTriangleFan_GrPrimitiveType:
             return 3;
         case kPoints_GrPrimitiveType:
             return 1;
@@ skipping 94 matching lines @@
     geometry.fColor = GrRandomColor(random);
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif