Improve caching of dashed paths in GrStencilAndCoverPathRenderer

src/gpu/gl/GrGLPath.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLPath.h"
 #include "GrGLPathRendering.h"
@@ skipping 73 matching lines @@
     for (size_t i = 0;  i < amount; ++i) {
         coords[i * 2] =  SkScalarToFloat(points[first_point + i].fX);
         coords[i * 2 + 1] = SkScalarToFloat(points[first_point + i].fY);
     }
 }
 }
 
 void GrGLPath::InitPathObject(GrGLGpu* gpu,
                               GrGLuint pathID,
                               const SkPath& skPath,
-                              const SkStrokeRec& stroke) {
+                              const GrStrokeInfo& stroke) {
+    SkASSERT(!stroke.isDashed());
     if (!skPath.isEmpty()) {
         int verbCnt = skPath.countVerbs();
         int pointCnt = skPath.countPoints();
         int minCoordCnt = pointCnt * 2;
 
         SkSTArray<16, GrGLubyte, true> pathCommands(verbCnt);
         SkSTArray<16, GrGLfloat, true> pathCoords(minCoordCnt);
 
         SkDEBUGCODE(int numCoords = 0);
 
@@ skipping 56 matching lines @@
 
         SkASSERT(verbCnt == pathCommands.count());
         SkASSERT(numCoords == pathCoords.count());
 
         GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
                    pathCoords.count(), GR_GL_FLOAT, &pathCoords[0]));
     } else {
         GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, 0, NULL, 0, GR_GL_FLOAT, NULL));
     }
 
-    if (stroke.needToApply()) {
-        SkASSERT(!stroke.isHairlineStyle());
+    const SkStrokeRec& strokeRec = stroke.getStrokeRec();
+    if (strokeRec.needToApply()) {
+        SkASSERT(!strokeRec.isHairlineStyle());
         GR_GL_CALL(gpu->glInterface(),
-            PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
+            PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(strokeRec.getWidth())));
         GR_GL_CALL(gpu->glInterface(),
-            PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(stroke.getMiter())));
-        GrGLenum join = join_to_gl_join(stroke.getJoin());
+            PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(strokeRec.getMiter())));
+        GrGLenum join = join_to_gl_join(strokeRec.getJoin());
         GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_JOIN_STYLE, join));
-        GrGLenum cap = cap_to_gl_cap(stroke.getCap());
+        GrGLenum cap = cap_to_gl_cap(strokeRec.getCap());
         GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_END_CAPS, cap));
     }
 }
 
-GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& path, const SkStrokeRec& stroke)
-    : INHERITED(gpu, path, stroke),
+GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& origStroke)
+    : INHERITED(gpu, origSkPath, origStroke),
       fPathID(gpu->glPathRendering()->genPaths(1)) {
 
-    InitPathObject(gpu, fPathID, fSkPath, stroke);
+    // Convert a dashing to either a stroke or a fill.
+    const SkPath* skPath = &origSkPath;
+    SkTLazy<SkPath> tmpPath;
+    const GrStrokeInfo* stroke = &origStroke;
+    GrStrokeInfo tmpStroke(origStroke, false);
 
-    if (stroke.needToApply()) {
+    if (stroke->isDashed()) {
+        if (stroke->applyDash(tmpPath.init(), &tmpStroke, *skPath)) {
+            skPath = tmpPath.get();
+            stroke = &tmpStroke;
+        }
+    }
+
+    InitPathObject(gpu, fPathID, *skPath, *stroke);
+
+    const SkStrokeRec& strokeRec = stroke->getStrokeRec();
+    fShouldStroke = strokeRec.needToApply();
+    fShouldFill = stroke->isFillStyle() ||
+            strokeRec.getStyle() == SkStrokeRec::kStrokeAndFill_Style;
+
+    if (fShouldStroke) {
         // FIXME: try to account for stroking, without rasterizing the stroke.
-        fBounds.outset(stroke.getWidth(), stroke.getWidth());
+        fBounds.outset(strokeRec.getWidth(), strokeRec.getWidth());
     }
+
     this->registerWithCache();
 }
 
 void GrGLPath::onRelease() {
     if (0 != fPathID && !this->isWrapped()) {
         static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
         fPathID = 0;
     }
 
     INHERITED::onRelease();
 }
 
 void GrGLPath::onAbandon() {
     fPathID = 0;
 
     INHERITED::onAbandon();
 }