Add dash lines batch unit test

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
+#include "GrBatchTest.h"
 #include "GrBufferAllocPool.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrStrokeInfo.h"
@@ skipping 229 matching lines @@
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
         SkScalar fIntervals[2];
         SkScalar fParallelScale;
         SkScalar fPerpendicularScale;
         SkDEBUGCODE(SkRect fDevBounds;)
     };
 
-    static GrBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode, bool fullDash) {
+    static GrBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode,
+                           bool fullDash) {
         return SkNEW_ARGS(DashBatch, (geometry, cap, aaMode, fullDash));
     }
 
     const char* name() const override { return "DashBatch"; }
 
     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 420 matching lines @@
         bool fFullDash;
     };
 
     static const int kVertsPerDash = 4;
     static const int kIndicesPerDash = 6;
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
-
-bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target,
-                                   GrPipelineBuilder* pipelineBuilder, GrColor color,
-                                   const SkMatrix& viewMatrix, const SkPoint pts[2],
-                                   bool useAA, const GrStrokeInfo& strokeInfo) {
+static GrBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
+                             bool useAA, const GrStrokeInfo& strokeInfo, bool msaaRT) {
     const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
 
     SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
 
     DashBatch::Geometry geometry;
     geometry.fSrcStrokeWidth = strokeInfo.getStrokeRec().getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
     SkASSERT(info.fPhase >= 0 && info.fPhase < info.fIntervals[0] + info.fIntervals[1]);
 
     // Rotate the src pts so they are aligned horizontally with pts[0].fX < pts[1].fX
     if (pts[0].fY != pts[1].fY || pts[0].fX > pts[1].fX) {
         SkMatrix rotMatrix;
         align_to_x_axis(pts, &rotMatrix, geometry.fPtsRot);
         if(!rotMatrix.invert(&geometry.fSrcRotInv)) {
             SkDebugf("Failed to create invertible rotation matrix!\n");
-            return false;
+            return NULL;
         }
     } else {
         geometry.fSrcRotInv.reset();
         memcpy(geometry.fPtsRot, pts, 2 * sizeof(SkPoint));
     }
 
     // Scale corrections of intervals and stroke from view matrix
     calc_dash_scaling(&geometry.fParallelScale, &geometry.fPerpendicularScale, viewMatrix,
                       geometry.fPtsRot);
 
     SkScalar offInterval = info.fIntervals[1] * geometry.fParallelScale;
     SkScalar strokeWidth = geometry.fSrcStrokeWidth * geometry.fPerpendicularScale;
 
     if (SkPaint::kSquare_Cap == cap && 0 != geometry.fSrcStrokeWidth) {
         // add cap to on interveal and remove from off interval
         offInterval -= strokeWidth;
     }
 
-    DashAAMode aaMode = pipelineBuilder->getRenderTarget()->isMultisampled() ? kMSAA_DashAAMode :
-                        useAA ? kEdgeAA_DashAAMode : kBW_DashAAMode;
+    DashAAMode aaMode = msaaRT ? kMSAA_DashAAMode :
+                                 useAA ? kEdgeAA_DashAAMode : kBW_DashAAMode;
 
     // TODO we can do a real rect call if not using fulldash(ie no off interval, not using AA)
     bool fullDash = offInterval > 0.f || aaMode != kBW_DashAAMode;
 
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPhase = info.fPhase;
     geometry.fIntervals[0] = info.fIntervals[0];
     geometry.fIntervals[1] = info.fIntervals[1];
 
-    SkAutoTUnref<GrBatch> batch(DashBatch::Create(geometry, cap, aaMode, fullDash));
+    return DashBatch::Create(geometry, cap, aaMode, fullDash);
+}
+
+bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target,
+                                   GrPipelineBuilder* pipelineBuilder, GrColor color,
+                                   const SkMatrix& viewMatrix, const SkPoint pts[2],
+                                   bool useAA, const GrStrokeInfo& strokeInfo) {
+    SkAutoTUnref<GrBatch> batch(create_batch(color, viewMatrix, pts, useAA, strokeInfo,
+                                             pipelineBuilder->getRenderTarget()->isMultisampled()));
+    if (!batch) {
+        return false;
+    }
+
     target->drawBatch(pipelineBuilder, batch);
-
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
 
 struct DashingCircleBatchTracker {
     GrGPInput fInputColorType;
     GrColor fColor;
@@ skipping 506 matching lines @@
     switch (cap) {
         case kRound_DashCap:
             return DashingCircleEffect::Create(color, dashAAMode, localMatrix);
         case kNonRound_DashCap:
             return DashingLineEffect::Create(color, dashAAMode, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef GR_TEST_UTILS
+
+BATCH_TEST_DEFINE(DashBatch) {
+    GrColor color = GrRandomColor(random);
+    SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
+    bool useAA = random->nextBool();
+    bool msaaRT = random->nextBool();
+
+    // We can only dash either horizontal or vertical lines
+    SkPoint pts[2];
+    if (random->nextBool()) {
+        // vertical
+        pts[0].fX = 1.f;
+        pts[0].fY = random->nextF() * 10.f;
+        pts[1].fX = 1.f;
+        pts[1].fY = random->nextF() * 10.f;
+    } else {
+        // horizontal
+        pts[0].fX = random->nextF() * 10.f;
+        pts[0].fY = 1.f;
+        pts[1].fX = random->nextF() * 10.f;
+        pts[1].fY = 1.f;
+    }
+
+    // pick random cap
+    SkPaint::Cap cap = SkPaint::Cap(random->nextULessThan(SkPaint::Cap::kCapCount));
+
+    SkScalar intervals[2];
+
+    // We can only dash with the following intervals
+    enum Intervals {
+        kOpenOpen_Intervals ,
+        kOpenClose_Intervals,
+        kCloseOpen_Intervals,
+    };
+
+    Intervals intervalType = SkPaint::kRound_Cap ?
+                             kOpenClose_Intervals :
+                             Intervals(random->nextULessThan(kCloseOpen_Intervals + 1));
+    static const SkScalar kIntervalMin = 0.1f;
+    static const SkScalar kIntervalMax = 10.f;
+    switch (intervalType) {
+        case kOpenOpen_Intervals:
+            intervals[0] = random->nextRangeScalar(kIntervalMin, kIntervalMax);
+            intervals[1] = random->nextRangeScalar(kIntervalMin, kIntervalMax);
+            break;
+        case kOpenClose_Intervals:
+            intervals[0] = 0.f;
+            intervals[1] = random->nextRangeScalar(kIntervalMin, kIntervalMax);
+            break;
+        case kCloseOpen_Intervals:
+            intervals[0] = random->nextRangeScalar(kIntervalMin, kIntervalMax);
+            intervals[1] = 0.f;
+            break;
+
+    }
+
+    // phase is 0 < sum (i0, i1)
+    SkScalar phase = random->nextRangeScalar(0, intervals[0] + intervals[1]);
+
+    SkPaint p;
+    p.setStyle(SkPaint::kStroke_Style);
+    p.setStrokeWidth(SkIntToScalar(1));
+    p.setStrokeCap(cap);
+
+    GrStrokeInfo strokeInfo(p);
+
+    SkPathEffect::DashInfo info;
+    info.fIntervals = intervals;
+    info.fCount = 2;
+    info.fPhase = phase;
+    SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
+    SkASSERT(success);
+
+    return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
+}
+
+#endif