Implement path cover with nv_path_rendering

src/gpu/GrDrawState.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
 #include "GrBackendEffectFactory.h"
 #include "GrBlend.h"
 #include "GrColor.h"
 #include "GrEffectStage.h"
 #include "GrPaint.h"
 #include "GrPoint.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
 #include "GrTemplates.h"
 #include "GrTexture.h"
 #include "GrTypesPriv.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "SkMatrix.h"
+#include "SkPath.h"
 #include "SkXfermode.h"
 
 class GrDrawState : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
 
     GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
@@ skipping 679 matching lines @@
      * Shortcut to disable stencil testing and ops.
      */
     void disableStencil() {
         fCommon.fStencilSettings.setDisabled();
     }
 
     const GrStencilSettings& getStencil() const { return fCommon.fStencilSettings; }
 
     GrStencilSettings* stencil() { return &fCommon.fStencilSettings; }
 
+    void setPathStencilFillType(SkPath::FillType fill) {
+        fCommon.fPathStencilFillType = fill;
+    }
+
+    SkPath::FillType getPathStencilFillType() const {
+        return fCommon.fPathStencilFillType;
+    }
+
+    SkPath::FillType* pathStencilFillType() {

[bsalomon, 2013/09/18 14:24:22]

Is this really needed? Skia very rarely returns pointers to members (that are
not themselves pointers).

+        return &fCommon.fPathStencilFillType;
+    }
+
+
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
 
     /**
      *  Flags that affect rendering. Controlled using enable/disableState(). All
      *  default to disabled.
      */
@@ skipping 172 matching lines @@
         if (NULL == initialViewMatrix) {
             fCommon.fViewMatrix.reset();
         } else {
             fCommon.fViewMatrix = *initialViewMatrix;
         }
         fCommon.fSrcBlend = kOne_GrBlendCoeff;
         fCommon.fDstBlend = kZero_GrBlendCoeff;
         fCommon.fBlendConstant = 0x0;
         fCommon.fFlagBits = 0x0;
         fCommon.fStencilSettings.setDisabled();
+        fCommon.fPathStencilFillType = SkPath::kWinding_FillType;
         fCommon.fCoverage = 0xffffffff;
         fCommon.fColorFilterMode = SkXfermode::kDst_Mode;
         fCommon.fColorFilterColor = 0x0;
         fCommon.fDrawFace = kBoth_DrawFace;
     }
 
     /** Fields that are identical in GrDrawState and GrDrawState::DeferredState. */
     struct CommonState {
         // These fields are roughly sorted by decreasing likelihood of being different in op==
         GrColor               fColor;
         SkMatrix              fViewMatrix;
         GrBlendCoeff          fSrcBlend;
         GrBlendCoeff          fDstBlend;
         GrColor               fBlendConstant;
         uint32_t              fFlagBits;
         const GrVertexAttrib* fVAPtr;
         int                   fVACount;
         GrStencilSettings     fStencilSettings;
+        SkPath::FillType      fPathStencilFillType;
         GrColor               fCoverage;
         SkXfermode::Mode      fColorFilterMode;
         GrColor               fColorFilterColor;
         DrawFace              fDrawFace;
 
         // This is simply a different representation of info in fVertexAttribs and thus does
         // not need to be compared in op==.
         int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
         bool operator== (const CommonState& other) const {
             bool result = fColor == other.fColor &&
                           fViewMatrix.cheapEqualTo(other.fViewMatrix) &&
                           fSrcBlend == other.fSrcBlend &&
                           fDstBlend == other.fDstBlend &&
                           fBlendConstant == other.fBlendConstant &&
                           fFlagBits == other.fFlagBits &&
                           fVACount == other.fVACount &&
                           !memcmp(fVAPtr, other.fVAPtr, fVACount * sizeof(GrVertexAttrib)) &&
                           fStencilSettings == other.fStencilSettings &&
+                          fPathStencilFillType == other.fPathStencilFillType &&
                           fCoverage == other.fCoverage &&
                           fColorFilterMode == other.fColorFilterMode &&
                           fColorFilterColor == other.fColorFilterColor &&
                           fDrawFace == other.fDrawFace;
             SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
                                             other.fFixedFunctionVertexAttribIndices,
                                             sizeof(fFixedFunctionVertexAttribIndices)));
             return result;
         }
         bool operator!= (const CommonState& other) const { return !(*this == other); }
@@ skipping 112 matching lines @@
      *  @param count      the number of attributes being set, limited to kMaxVertexAttribCnt.
      */
     void setVertexAttribs(const GrVertexAttrib attribs[], int count);
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif