1 files changed, 37 insertions, 17 deletions

diff --git a/src/gpu/ccpr/GrCCCoverageProcessor.h b/src/gpu/ccpr/GrCCCoverageProcessor.h
index 1296e089dc..e6adfffe14 100644
--- a/src/gpu/ccpr/GrCCCoverageProcessor.h
+++ b/src/gpu/ccpr/GrCCCoverageProcessor.h
@@ -33,8 +33,9 @@ class GrMesh;
  */
 class GrCCCoverageProcessor : public GrGeometryProcessor {
 public:
-    // Defines a single triangle or closed quadratic bezier, with transposed x,y point values.
-    struct TriangleInstance {
+    // Defines a single primitive shape with 3 input points (i.e. Triangles and Quadratics).
+    // X,Y point values are transposed.
+    struct TriPointInstance {
         float fX[3];
         float fY[3];
 
@@ -42,12 +43,15 @@ public:
         void set(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& trans);
     };
 
-    // Defines a single closed cubic bezier, with transposed x,y point values.
-    struct CubicInstance {
+    // Defines a single primitive shape with 4 input points, or 3 input points plus a W parameter
+    // duplicated in both 4th components (i.e. Cubics or Triangles with a custom winding number).
+    // X,Y point values are transposed.
+    struct QuadPointInstance {
         float fX[4];
         float fY[4];
 
         void set(const SkPoint[4], float dx, float dy);
+        void set(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& trans, float w);
     };
 
     // All primitive shapes (triangles and closed, convex bezier curves) require more than one
@@ -93,24 +97,29 @@ public:
                caps.shaderCaps()->geometryShaderSupport();
     }
 
-    GrCCCoverageProcessor(GrResourceProvider* rp, RenderPass pass, const GrCaps& caps)
+    enum class WindMethod : bool {
+        kCrossProduct, // Calculate wind = +/-1 by sign of the cross product.
+        kInstanceData // Instance data provides custom, signed wind values of any magnitude.
+                      // (For tightly-wound tessellated triangles.)
+    };
+
+    GrCCCoverageProcessor(GrResourceProvider* rp, RenderPass pass, WindMethod windMethod)
             : INHERITED(kGrCCCoverageProcessor_ClassID)
             , fRenderPass(pass)
-            , fImpl(caps.shaderCaps()->geometryShaderSupport() ? Impl::kGeometryShader
-                                                               : Impl::kVertexShader) {
-        SkASSERT(DoesRenderPass(pass, caps));
+            , fWindMethod(windMethod)
+            , fImpl(rp->caps()->shaderCaps()->geometryShaderSupport() ? Impl::kGeometryShader
+                                                                      : Impl::kVertexShader) {
+        SkASSERT(DoesRenderPass(pass, *rp->caps()));
         if (Impl::kGeometryShader == fImpl) {
             this->initGS();
         } else {
-            this->initVS(rp, caps);
+            this->initVS(rp);
         }
     }
 
     // Appends a GrMesh that will draw the provided instances. The instanceBuffer must be an array
-    // of either TriangleInstance or CubicInstance, depending on this processor's RendererPass, with
-    // coordinates in the desired shape's final atlas-space position.
-    //
-    // NOTE: Quadratics use TriangleInstance since both have 3 points.
+    // of either TriPointInstance or QuadPointInstance, depending on this processor's RendererPass,
+    // with coordinates in the desired shape's final atlas-space position.
     void appendMesh(GrBuffer* instanceBuffer, int instanceCount, int baseInstance,
                     SkTArray<GrMesh>* out) {
         if (Impl::kGeometryShader == fImpl) {
@@ -227,7 +236,7 @@ private:
     };
 
     void initGS();
-    void initVS(GrResourceProvider*, const GrCaps&);
+    void initVS(GrResourceProvider*);
 
     void appendGSMesh(GrBuffer* instanceBuffer, int instanceCount, int baseInstance,
                       SkTArray<GrMesh>* out) const;
@@ -238,6 +247,7 @@ private:
     GrGLSLPrimitiveProcessor* createVSImpl(std::unique_ptr<Shader>) const;
 
     const RenderPass fRenderPass;
+    const WindMethod fWindMethod;
     const Impl fImpl;
     SkDEBUGCODE(float fDebugBloat = 0);
 
@@ -250,11 +260,11 @@ private:
     typedef GrGeometryProcessor INHERITED;
 };
 
-inline void GrCCCoverageProcessor::TriangleInstance::set(const SkPoint p[3], const Sk2f& trans) {
+inline void GrCCCoverageProcessor::TriPointInstance::set(const SkPoint p[3], const Sk2f& trans) {
     this->set(p[0], p[1], p[2], trans);
 }
 
-inline void GrCCCoverageProcessor::TriangleInstance::set(const SkPoint& p0, const SkPoint& p1,
+inline void GrCCCoverageProcessor::TriPointInstance::set(const SkPoint& p0, const SkPoint& p1,
                                                          const SkPoint& p2, const Sk2f& trans) {
     Sk2f P0 = Sk2f::Load(&p0) + trans;
     Sk2f P1 = Sk2f::Load(&p1) + trans;
@@ -262,13 +272,23 @@ inline void GrCCCoverageProcessor::TriangleInstance::set(const SkPoint& p0, cons
     Sk2f::Store3(this, P0, P1, P2);
 }
 
-inline void GrCCCoverageProcessor::CubicInstance::set(const SkPoint p[4], float dx, float dy) {
+inline void GrCCCoverageProcessor::QuadPointInstance::set(const SkPoint p[4], float dx, float dy) {
     Sk4f X,Y;
     Sk4f::Load2(p, &X, &Y);
     (X + dx).store(&fX);
     (Y + dy).store(&fY);
 }
 
+inline void GrCCCoverageProcessor::QuadPointInstance::set(const SkPoint& p0, const SkPoint& p1,
+                                                          const SkPoint& p2, const Sk2f& trans,
+                                                          float w) {
+    Sk2f P0 = Sk2f::Load(&p0) + trans;
+    Sk2f P1 = Sk2f::Load(&p1) + trans;
+    Sk2f P2 = Sk2f::Load(&p2) + trans;
+    Sk2f W = Sk2f(w);
+    Sk2f::Store4(this, P0, P1, P2, W);
+}
+
 inline bool GrCCCoverageProcessor::RenderPassIsCubic(RenderPass pass) {
     switch (pass) {
         case RenderPass::kTriangleHulls: