Pass dashing information to path rasterizers.

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 1426 matching lines @@
     bool useCoverageAA = useAA &&
         !pipelineBuilder->getRenderTarget()->isMultisampled();
 
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
                         GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
-    SkTCopyOnFirstWrite<SkStrokeRec> stroke(strokeInfo.getStrokeRec());
+    GrStrokeInfo stroke(strokeInfo);
 
     // Try a 1st time without stroking the path and without allowing the SW renderer
     GrPathRenderer* pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr,
-                                               *stroke, false, type);
+                                               stroke, false, type);
 
     if (NULL == pr) {
-        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(*stroke, viewMatrix, NULL)) {
+        if (!GrPathRenderer::IsStrokeHairlineOrEquivalent(stroke.getStrokeRec(), viewMatrix,
+                                                          NULL)) {
             // It didn't work the 1st time, so try again with the stroked path
-            stroke.writable()->setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
-            if (stroke->applyToPath(tmpPath.init(), *pathPtr)) {
+            stroke.getStrokeRecPtr()->setResScale(SkScalarAbs(viewMatrix.getMaxScale()));
+            if (stroke.getStrokeRec().applyToPath(tmpPath.init(), *pathPtr)) {

[bsalomon, 2015/04/16 17:53:38]

need to apply path effect here, right?

                 pathPtr = tmpPath.get();
-                stroke.writable()->setFillStyle();
+                stroke.getStrokeRecPtr()->setFillStyle();

[bsalomon, 2015/04/16 17:52:18]

Seems like this should also remove the path effect to. Should we have something
like

static const GrStrokeInfo& GrStrokeInfo::FillInfo();

It'd just be a static function that creates a static GrStrokeInfo for filling
and returns it.

I realize it's already there, but don't love "getStrokeRecPtr()" and would
prefer to avoid using it.

                 if (pathPtr->isEmpty()) {
                     return;
                 }
             }
         }
 
         // This time, allow SW renderer
-        pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, *stroke, true,
+        pr = this->getPathRenderer(target, pipelineBuilder, viewMatrix, *pathPtr, stroke, true,
                                    type);
     }
 
     if (NULL == pr) {
 #ifdef SK_DEBUG
         SkDebugf("Unable to find path renderer compatible with path.\n");
 #endif
         return;
     }
 
-    pr->drawPath(target, pipelineBuilder, color, viewMatrix, *pathPtr, *stroke, useCoverageAA);
+    pr->drawPath(target, pipelineBuilder, color, viewMatrix, *pathPtr, stroke, useCoverageAA);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrContext::flush(int flagsBitfield) {
     if (NULL == fDrawBuffer) {
         return;
     }
 
     if (kDiscard_FlushBit & flagsBitfield) {
@@ skipping 376 matching lines @@
 /*
  * This method finds a path renderer that can draw the specified path on
  * the provided target.
  * Due to its expense, the software path renderer has split out so it can
  * can be individually allowed/disallowed via the "allowSW" boolean.
  */
 GrPathRenderer* GrContext::getPathRenderer(const GrDrawTarget* target,
                                            const GrPipelineBuilder* pipelineBuilder,
                                            const SkMatrix& viewMatrix,
                                            const SkPath& path,
-                                           const SkStrokeRec& stroke,
+                                           const GrStrokeInfo& stroke,
                                            bool allowSW,
                                            GrPathRendererChain::DrawType drawType,
                                            GrPathRendererChain::StencilSupport* stencilSupport) {
 
     if (NULL == fPathRendererChain) {
         fPathRendererChain = SkNEW_ARGS(GrPathRendererChain, (this));
     }
 
     GrPathRenderer* pr = fPathRendererChain->getPathRenderer(target,
                                                              pipelineBuilder,
@@ skipping 144 matching lines @@
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }