Improve caching of dashed paths in GrStencilAndCoverPathRenderer

src/gpu/gl/GrGLPathRendering.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 "gl/GrGLPathRendering.h"
 #include "gl/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
@@ skipping 73 matching lines @@
 
 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
     SkASSERT(fCaps.fragmentInputGenSupport);
     fHWPathStencilSettings.invalidate();
 }
 
-GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const SkStrokeRec& stroke) {
+GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPath, (fGpu, inPath, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
-                                                const SkStrokeRec& stroke) {
+                                                const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPathRange, (fGpu, pathGenerator, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createGlyphs(const SkTypeface* typeface,
                                              const SkDescriptor* desc,
-                                             const SkStrokeRec& stroke) {
-    if (NULL != desc || !caps().glyphLoadingSupport) {
+                                             const GrStrokeInfo& stroke) {
+    if (NULL != desc || !caps().glyphLoadingSupport || stroke.isDashed()) {
         return GrPathRendering::createGlyphs(typeface, desc, stroke);
     }
 
     if (NULL == typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
         SkASSERT(NULL != typeface);
     }
 
     int faceIndex;
     SkAutoTDelete<SkStream> fontStream(typeface->openStream(&faceIndex));
@@ skipping 28 matching lines @@
     }
 
     // This is a crude approximation. We may want to consider giving this class
     // a pseudo PathGenerator whose sole purpose is to track the approximate gpu
     // memory size.
     const size_t gpuMemorySize = fontDataLength / 4;
     return SkNEW_ARGS(GrGLPathRange, (fGpu, basePathID, numPaths, gpuMemorySize, stroke));
 }
 
 void GrGLPathRendering::stencilPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
-    GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
+    const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
     this->flushPathStencilSettings(stencilSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
-    const SkStrokeRec& stroke = path->getStroke();
-
-    GrGLenum fillMode =
-        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+        fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
-    if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-        GL_CALL(StencilFillPath(id, fillMode, writeMask));
+    if (glPath->shouldFill()) {
+        GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
     }
-    if (stroke.needToApply()) {
-        GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
+    if (glPath->shouldStroke()) {
+        GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
     }
 }
 
 void GrGLPathRendering::drawPath(const GrPath* path, const GrStencilSettings& stencilSettings) {
-    GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
+    const GrGLPath* glPath = static_cast<const GrGLPath*>(path);
 
     this->flushPathStencilSettings(stencilSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
-    const SkStrokeRec& stroke = path->getStroke();
-
-    GrGLenum fillMode =
-        gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
+    GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+        fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
-    if (stroke.needToApply()) {
-        if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
-            GL_CALL(StencilFillPath(id, fillMode, writeMask));
+    if (glPath->shouldStroke()) {
+        if (glPath->shouldFill()) {
+            GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
-        this->stencilThenCoverStrokePath(id, 0xffff, writeMask, GR_GL_BOUNDING_BOX);
+        this->stencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask, GR_GL_BOUNDING_BOX);
     } else {
-        this->stencilThenCoverFillPath(id, fillMode, writeMask, GR_GL_BOUNDING_BOX);
+        this->stencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask, GR_GL_BOUNDING_BOX);
     }
 }
 
 void GrGLPathRendering::drawPaths(const GrPathRange* pathRange,
                                   const void* indices, PathIndexType indexType,
                                   const float transformValues[], PathTransformType transformType,
                                   int count, const GrStencilSettings& stencilSettings) {
     SkASSERT(fGpu->caps()->shaderCaps()->pathRenderingSupport());
 
-    GrGLuint baseID = static_cast<const GrGLPathRange*>(pathRange)->basePathID();
+    const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);
 
     this->flushPathStencilSettings(stencilSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());
 
-    const SkStrokeRec& stroke = pathRange->getStroke();
-
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(
             fHWPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask =
         fHWPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
 
-    if (stroke.needToApply()) {
-        if (SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
+    if (glPathRange->shouldStroke()) {
+        if (glPathRange->shouldFill()) {
             GL_CALL(StencilFillPathInstanced(
-                            count, gIndexType2GLType[indexType], indices, baseID, fillMode,
-                            writeMask, gXformType2GLType[transformType], transformValues));
+                            count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
+                            fillMode, writeMask, gXformType2GLType[transformType],
+                            transformValues));
         }
         this->stencilThenCoverStrokePathInstanced(
-                            count, gIndexType2GLType[indexType], indices, baseID,
+                            count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues);
     } else {
         this->stencilThenCoverFillPathInstanced(
-                            count, gIndexType2GLType[indexType], indices, baseID,
+                            count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues);
     }
 }
 
 void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
                                                              GrGLenum genMode, GrGLint components,
                                                              const SkMatrix& matrix) {
     SkASSERT(caps().fragmentInputGenSupport);
     GrGLfloat coefficients[3 * 3];
@@ skipping 147 matching lines @@
                                                     reference, mask, coverMode, transformType,
                                                     transformValues));
         return;
     }
 
     GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                        reference, mask, transformType, transformValues));
     GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                      coverMode, transformType, transformValues));
 }