Make GrShape capable of representing inverse filled rrects.

src/gpu/GrShape.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrShape_DEFINED
 #define GrShape_DEFINED
 
@@ skipping 26 matching lines @@
     GrShape() : fType(Type::kEmpty) {}
 
     explicit GrShape(const SkPath& path)
         : fType(Type::kPath)
         , fPath(&path) {
         this->attemptToReduceFromPath();
     }
 
     explicit GrShape(const SkRRect& rrect)
         : fType(Type::kRRect)
-        , fRRect(rrect) {
+        , fRRect(rrect)
+        , fRRectIsInverted(false) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
     explicit GrShape(const SkRect& rect)
         : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect)) {
+        , fRRect(SkRRect::MakeRect(rect))
+        , fRRectIsInverted(false) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, false, &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
     GrShape(const SkPath& path, const GrStyle& style)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(style) {
         this->attemptToReduceFromPath();
     }
 
     GrShape(const SkRRect& rrect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(rrect)
+        , fRRectIsInverted(false)
         , fStyle(style) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, style.hasPathEffect(), &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
-    GrShape(const SkRRect& rrect, SkPath::Direction dir, unsigned start, const GrStyle& style)
+    GrShape(const SkRRect& rrect, SkPath::Direction dir, unsigned start, bool inverted,
+            const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(rrect)
+        , fRRectIsInverted(inverted)
         , fStyle(style) {
         if (style.pathEffect()) {
             fRRectDir = dir;
             fRRectStart = start;
+            if (fRRect.getType() == SkRRect::kRect_Type) {
+                fRRectStart = (fRRectStart + 1) & 0b110;
+            } else if (fRRect.getType() == SkRRect::kOval_Type) {
+                fRRectStart &= 0b110;
+            }
         } else {
             fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
         }
         this->attemptToReduceFromRRect();
     }
 
     GrShape(const SkRect& rect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
+        , fRRectIsInverted(false)
         , fStyle(style) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, style.hasPathEffect(), &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
     GrShape(const SkPath& path, const SkPaint& paint)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(paint) {
         this->attemptToReduceFromPath();
     }
 
     GrShape(const SkRRect& rrect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(rrect)
+        , fRRectIsInverted(false)
         , fStyle(paint) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, fStyle.hasPathEffect(), &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
     GrShape(const SkRect& rect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
+        , fRRectIsInverted(false)
         , fStyle(paint) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, fStyle.hasPathEffect(), &fRRectDir);
         this->attemptToReduceFromRRect();
     }
 
     GrShape(const GrShape&);
     GrShape& operator=(const GrShape& that);
 
     ~GrShape() {
         if (Type::kPath == fType) {
             fPath.reset();
         }
     }
 
     const GrStyle& style() const { return fStyle; }
 
     /**
      * Returns a shape that has either applied the path effect or path effect and stroking
      * information from this shape's style to its geometry. Scale is used when approximating the
      * output geometry and typically is computed from the view matrix
      */
     GrShape applyStyle(GrStyle::Apply apply, SkScalar scale) {
         return GrShape(*this, apply, scale);
     }
 
     /** Returns the unstyled geometry as a rrect if possible. */
-    bool asRRect(SkRRect* rrect, SkPath::Direction* dir, unsigned* start) const {
+    bool asRRect(SkRRect* rrect, SkPath::Direction* dir, unsigned* start, bool* inverted) const {
         if (Type::kRRect != fType) {
             return false;
         }
         if (rrect) {
             *rrect = fRRect;
         }
         if (dir) {
             *dir = fRRectDir;
         }
         if (start) {
             *start = fRRectStart;
         }
+        if (inverted) {
+            *inverted = fRRectIsInverted;
+        }
         return true;
     }
 
     /** Returns the unstyled geometry as a path. */
     void asPath(SkPath* out) const {
         switch (fType) {
             case Type::kEmpty:
                 out->reset();
                 break;
             case Type::kRRect:
                 out->reset();
                 out->addRRect(fRRect, fRRectDir, fRRectStart);
+                if (fRRectIsInverted) {
+                    out->setFillType(SkPath::kInverseWinding_FillType);
+                }
                 break;
             case Type::kPath:
                 *out = *fPath.get();
                 break;
         }
     }
 
     /**
      * Returns whether the geometry is empty. Note that applying the style could produce a
      * non-empty shape.
      */
     bool isEmpty() const { return Type::kEmpty == fType; }
 
-    /** Gets the bounds of the geometry without reflecting the shape's styling. */
+    /**
+     * Gets the bounds of the geometry without reflecting the shape's styling. This ignores
+     * the inverse fill nature of the geometry.
+     */
     const SkRect& bounds() const;
 
-    /** Gets the bounds of the geometry reflecting the shape's styling. */
+    /**
+     * Gets the bounds of the geometry reflecting the shape's styling (ignoring inverse fill
+     * status).
+     */
     void styledBounds(SkRect* bounds) const;
 
     /**
      * Is it known that the unstyled geometry has no unclosed contours. This means that it will
      * not have any caps if stroked (modulo the effect of any path effect).
      */
     bool knownToBeClosed() const {
         switch (fType) {
             case Type::kEmpty:
                 return true;
@@ skipping 47 matching lines @@
 
     /**
      * Determines the key we should inherit from the input shape's geometry and style when
      * we are applying the style to create a new shape.
      */
     void setInheritedKey(const GrShape& parentShape, GrStyle::Apply, SkScalar scale);
 
     void attemptToReduceFromPath() {
         SkASSERT(Type::kPath == fType);
         fType = AttemptToReduceFromPathImpl(*fPath.get(), &fRRect, &fRRectDir, &fRRectStart,
-                                            fStyle.pathEffect(), fStyle.strokeRec());
+                                            &fRRectIsInverted, fStyle.pathEffect(),
+                                            fStyle.strokeRec());
         if (Type::kPath != fType) {
             fPath.reset();
             fInheritedKey.reset(0);
         }
     }
 
     void attemptToReduceFromRRect() {
         SkASSERT(Type::kRRect == fType);
         SkASSERT(!fInheritedKey.count());
-        if (fRRect.isEmpty()) {
+        if (fRRectIsInverted) {
+            if (!fStyle.hasNonDashPathEffect()) {
+                SkStrokeRec::Style recStyle = fStyle.strokeRec().getStyle();
+                if (SkStrokeRec::kStroke_Style == recStyle ||
+                    SkStrokeRec::kHairline_Style == recStyle) {
+                    // stroking ignores the path fill rule.
+                    fRRectIsInverted = false;
+                }
+            }
+        } else if (fRRect.isEmpty()) {
             fType = Type::kEmpty;
         }
     }
 
     static Type AttemptToReduceFromPathImpl(const SkPath& path, SkRRect* rrect,
                                             SkPath::Direction* rrectDir, unsigned* rrectStart,
-                                            const SkPathEffect* pe, const SkStrokeRec& strokeRec);
+                                            bool* rrectIsInverted, const SkPathEffect* pe,
+                                            const SkStrokeRec& strokeRec);
 
     static constexpr SkPath::Direction kDefaultRRectDir = SkPath::kCW_Direction;
     static constexpr unsigned kDefaultRRectStart = 0;
 
     static unsigned DefaultRectDirAndStartIndex(const SkRect& rect, bool hasPathEffect,
                                                 SkPath::Direction* dir) {
         *dir = kDefaultRRectDir;
         // This comes from SkPath's interface. The default for adding a SkRect is counter clockwise
         // beginning at index 0 (which happens to correspond to rrect index 0 or 7).
         if (!hasPathEffect) {
@@ skipping 30 matching lines @@
             // It doesn't matter what start we use, just be consistent to avoid redundant keys.
             return kDefaultRRectStart;
         }
         return kPathRRectStartIdx;
     }
 
     Type                        fType;
     SkRRect                     fRRect;
     SkPath::Direction           fRRectDir;
     unsigned                    fRRectStart;
+    bool                        fRRectIsInverted;
     SkTLazy<SkPath>             fPath;
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif