Implement stroking a path with nv_path_rendering

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
 #include "GrGLPath.h"
 #include "GrGLShaderBuilder.h"
 #include "GrTemplates.h"
 #include "GrTypes.h"
+#include "SkStrokeRec.h"
 #include "SkTemplates.h"
 
 static const GrGLuint GR_MAX_GLUINT = ~0U;
 static const GrGLint  GR_INVAL_GLINT = ~0;
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 #define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->glInterface(), RET, X)
 
 
 #define SKIP_CACHE_CHECK    true
@@ skipping 1241 matching lines @@
                 this->notifyIndexBufferDelete(desc.fID);
                 return NULL;
             }
             GrIndexBuffer* indexBuffer = SkNEW_ARGS(GrGLIndexBuffer, (this, desc));
             return indexBuffer;
         }
         return NULL;
     }
 }
 
-GrPath* GrGpuGL::onCreatePath(const SkPath& inPath) {
+GrPath* GrGpuGL::onCreatePath(const SkPath& inPath, const SkStrokeRec& stroke) {
     SkASSERT(this->caps()->pathRenderingSupport());
-    return SkNEW_ARGS(GrGLPath, (this, inPath));
+    return SkNEW_ARGS(GrGLPath, (this, inPath, stroke));
 }
 
 void GrGpuGL::flushScissor() {
     const GrDrawState& drawState = this->getDrawState();
     const GrGLRenderTarget* rt =
         static_cast<const GrGLRenderTarget*>(drawState.getRenderTarget());
 
     SkASSERT(NULL != rt);
     const GrGLIRect& vp = rt->getViewport();
 
@@ skipping 432 matching lines @@
 
     // Decide how to manipulate the stencil buffer based on the fill rule.
     SkASSERT(!fPathStencilSettings.isTwoSided());
 
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
     GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
-void GrGpuGL::onGpuFillPath(const GrPath* path, SkPath::FillType fill) {
+void GrGpuGL::onGpuDrawPath(const GrPath* path, const SkStrokeRec& stroke, SkPath::FillType fill) {
     SkASSERT(this->caps()->pathRenderingSupport());
 
     GrGLuint id = static_cast<const GrGLPath*>(path)->pathID();
     GrDrawState* drawState = this->drawState();
     SkASSERT(NULL != drawState->getRenderTarget());
     SkASSERT(NULL != drawState->getRenderTarget()->getStencilBuffer());
 
-    SkPath::FillType nonInvertedFill = SkPath::ConvertToNonInverseFillType(fill);
     SkASSERT(!fPathStencilSettings.isTwoSided());
     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fPathStencilSettings.passOp(GrStencilSettings::kFront_Face));
     GrGLint writeMask = fPathStencilSettings.writeMask(GrStencilSettings::kFront_Face);
-    GL_CALL(StencilFillPath(id, fillMode, writeMask));
 
-    if (!fCurrentProgram->hasVertexShader() && nonInvertedFill == fill) {
-        GL_CALL(CoverFillPath(id, GR_GL_BOUNDING_BOX));
+    if (stroke.isFillStyle() || SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle()) {
+        GL_CALL(StencilFillPath(id, fillMode, writeMask));
+    }
+
+    if (stroke.needToApply()) {
+        GL_CALL(StencilStrokePath(id, 0xffff, writeMask));
+    }
+
+    bool isInverseFill = SkPath::ConvertToNonInverseFillType(fill) != fill;
+
+    if (!fCurrentProgram->hasVertexShader() && !isInverseFill) {
+        if (stroke.needToApply()) {
+            GL_CALL(CoverStrokePath(id, GR_GL_BOUNDING_BOX));
+        } else {
+            GL_CALL(CoverFillPath(id, GR_GL_BOUNDING_BOX));
+        }
     } else {
         GrDrawState::AutoViewMatrixRestore avmr;
+        SkMatrix vmi;
         SkRect bounds;
-        if (nonInvertedFill == fill) {
+        if (!isInverseFill) {
             bounds = path->getBounds();
         } else {
             bounds = SkRect::MakeLTRB(0, 0,
                                       SkIntToScalar(drawState->getRenderTarget()->width()),
-                                      SkIntToScalar(drawState->getRenderTarget()->height()));
-            SkMatrix vmi;
+                                  SkIntToScalar(drawState->getRenderTarget()->height()));
+
             // mapRect through persp matrix may not be correct
             if (!drawState->getViewMatrix().hasPerspective() && drawState->getViewInverse(&vmi)) {
                 vmi.mapRect(&bounds);
                 // theoretically could set bloat = 0, instead leave it because of matrix inversion
                 // precision.
                 SkScalar bloat = drawState->getViewMatrix().getMaxStretch() * SK_ScalarHalf;
                 bounds.outset(bloat, bloat);
             } else {
                 avmr.setIdentity(drawState);
             }
@@ skipping 117 matching lines @@
         GR_GL_CALL(gl, StencilOp(glFailOp, glPassOp, glPassOp));
     } else {
         GR_GL_CALL(gl, StencilFuncSeparate(glFace, glFunc, ref, mask));
         GR_GL_CALL(gl, StencilMaskSeparate(glFace, writeMask));
         GR_GL_CALL(gl, StencilOpSeparate(glFace, glFailOp, glPassOp, glPassOp));
     }
 }
 }
 
 void GrGpuGL::flushStencil(DrawType type) {
-    if ((kStencilPath_DrawType == type || kFillPath_DrawType == type) &&
+    if ((kStencilPath_DrawType == type || kDrawPath_DrawType == type) &&
         fHWPathStencilSettings != fPathStencilSettings) {
 
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
         GrGLenum func =
             gr_to_gl_stencil_func(fPathStencilSettings.func(GrStencilSettings::kFront_Face));
         GL_CALL(PathStencilFunc(func,
                                 fPathStencilSettings.funcRef(GrStencilSettings::kFront_Face),
                                 fPathStencilSettings.funcMask(GrStencilSettings::kFront_Face)));
 
@@ skipping 314 matching lines @@
                        numComponents,
                        coefficients));
 
     memcpy(fHWTexGenSettings[unitIdx].fCoefficients, coefficients,
            3 * numComponents * sizeof(GrGLfloat));
 
     fHWActiveTexGenUnits = SkTMax(fHWActiveTexGenUnits, unitIdx);
 }
 
 void GrGpuGL::enableTexGen(int unitIdx, int numComponents, const SkMatrix& matrix) {
-
     GrGLfloat coefficients[9];
     SkASSERT(this->glCaps().fixedFunctionSupport());
     SkASSERT(numComponents <= 3 && numComponents > 0);
 
     coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
     coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
     coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);
 
     if (numComponents >= 2) {
         coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
@@ skipping 506 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }