| /* |
| * 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 GrStyledShape_DEFINED |
| #define GrStyledShape_DEFINED |
| |
| #include "include/core/SkPath.h" |
| #include "include/core/SkRRect.h" |
| #include "include/private/SkTemplates.h" |
| #include "src/core/SkPathPriv.h" |
| #include "src/core/SkTLazy.h" |
| #include "src/gpu/GrStyle.h" |
| #include "src/gpu/geometry/GrShape.h" |
| #include <new> |
| |
| class SkIDChangeListener; |
| |
| /** |
| * Represents a geometric shape (rrect or path) and the GrStyle that it should be rendered with. |
| * It is possible to apply the style to the GrStyledShape to produce a new GrStyledShape where the |
| * geometry reflects the styling information (e.g. is stroked). It is also possible to apply just |
| * the path effect from the style. In this case the resulting shape will include any remaining |
| * stroking information that is to be applied after the path effect. |
| * |
| * Shapes can produce keys that represent only the geometry information, not the style. Note that |
| * when styling information is applied to produce a new shape then the style has been converted |
| * to geometric information and is included in the new shape's key. When the same style is applied |
| * to two shapes that reflect the same underlying geometry the computed keys of the stylized shapes |
| * will be the same. |
| * |
| * Currently this can only be constructed from a path, rect, or rrect though it can become a path |
| * applying style to the geometry. The idea is to expand this to cover most or all of the geometries |
| * that have fast paths in the GPU backend. |
| */ |
| class GrStyledShape { |
| public: |
| // Keys for paths may be extracted from the path data for small paths. Clients aren't supposed |
| // to have to worry about this. This value is exposed for unit tests. |
| static constexpr int kMaxKeyFromDataVerbCnt = 10; |
| |
| GrStyledShape() {} |
| |
| enum class DoSimplify : bool { kNo = false, kYes }; |
| |
| explicit GrStyledShape(const SkPath& path, DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(path, GrStyle::SimpleFill(), doSimplify) {} |
| |
| explicit GrStyledShape(const SkRRect& rrect, DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(rrect, GrStyle::SimpleFill(), doSimplify) {} |
| |
| explicit GrStyledShape(const SkRect& rect, DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(rect, GrStyle::SimpleFill(), doSimplify) {} |
| |
| GrStyledShape(const SkPath& path, const SkPaint& paint, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(path, GrStyle(paint), doSimplify) {} |
| |
| GrStyledShape(const SkRRect& rrect, const SkPaint& paint, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(rrect, GrStyle(paint), doSimplify) {} |
| |
| GrStyledShape(const SkRect& rect, const SkPaint& paint, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : GrStyledShape(rect, GrStyle(paint), doSimplify) {} |
| |
| GrStyledShape(const SkPath& path, const GrStyle& style, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : fShape(path), fStyle(style) { |
| if (doSimplify == DoSimplify::kYes) { |
| this->simplify(); |
| } |
| } |
| |
| GrStyledShape(const SkRRect& rrect, const GrStyle& style, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : fShape(rrect), fStyle(style) { |
| if (doSimplify == DoSimplify::kYes) { |
| this->simplify(); |
| } |
| } |
| |
| GrStyledShape(const SkRRect& rrect, SkPathDirection dir, unsigned start, bool inverted, |
| const GrStyle& style, DoSimplify doSimplify = DoSimplify::kYes) |
| : fShape(rrect) |
| , fStyle(style) { |
| fShape.setPathWindingParams(dir, start); |
| fShape.setInverted(inverted); |
| if (doSimplify == DoSimplify::kYes) { |
| this->simplify(); |
| } |
| } |
| |
| GrStyledShape(const SkRect& rect, const GrStyle& style, |
| DoSimplify doSimplify = DoSimplify::kYes) |
| : fShape(rect), fStyle(style) { |
| if (doSimplify == DoSimplify::kYes) { |
| this->simplify(); |
| } |
| } |
| |
| GrStyledShape(const GrStyledShape&); |
| |
| static GrStyledShape MakeArc(const SkRect& oval, SkScalar startAngleDegrees, |
| SkScalar sweepAngleDegrees, bool useCenter, const GrStyle& style, |
| DoSimplify = DoSimplify::kYes); |
| |
| GrStyledShape& operator=(const GrStyledShape& that); |
| |
| /** |
| * Informs MakeFilled on how to modify that shape's fill rule when making a simple filled |
| * version of the shape. |
| */ |
| enum class FillInversion { |
| kPreserve, |
| kFlip, |
| kForceNoninverted, |
| kForceInverted |
| }; |
| /** |
| * Makes a filled shape from the pre-styled original shape and optionally modifies whether |
| * the fill is inverted or not. It's important to note that the original shape's geometry |
| * may already have been modified if doing so was neutral with respect to its style |
| * (e.g. filled paths are always closed when stored in a shape and dashed paths are always |
| * made non-inverted since dashing ignores inverseness). |
| */ |
| static GrStyledShape MakeFilled(const GrStyledShape& original, |
| FillInversion = FillInversion::kPreserve); |
| |
| const GrStyle& style() const { return fStyle; } |
| |
| // True if the shape and/or style were modified into a simpler, equivalent pairing |
| bool simplified() const { return fSimplified; } |
| |
| /** |
| * 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 |
| */ |
| GrStyledShape applyStyle(GrStyle::Apply apply, SkScalar scale) const { |
| return GrStyledShape(*this, apply, scale); |
| } |
| |
| bool isRect() const { |
| // Should have simplified a rrect to a rect if possible already. |
| SkASSERT(!fShape.isRRect() || !fShape.rrect().isRect()); |
| return fShape.isRect(); |
| } |
| |
| /** Returns the unstyled geometry as a rrect if possible. */ |
| bool asRRect(SkRRect* rrect, SkPathDirection* dir, unsigned* start, bool* inverted) const; |
| |
| /** |
| * If the unstyled shape is a straight line segment, returns true and sets pts to the endpoints. |
| * An inverse filled line path is still considered a line. |
| */ |
| bool asLine(SkPoint pts[2], bool* inverted) const; |
| |
| // Can this shape be drawn as a pair of filled nested rectangles? |
| bool asNestedRects(SkRect rects[2]) const; |
| |
| /** Returns the unstyled geometry as a path. */ |
| void asPath(SkPath* out) const { |
| fShape.asPath(out, fStyle.isSimpleFill()); |
| } |
| |
| /** |
| * Returns whether the geometry is empty. Note that applying the style could produce a |
| * non-empty shape. It also may have an inverse fill. |
| */ |
| bool isEmpty() const { return fShape.isEmpty(); } |
| |
| /** |
| * Gets the bounds of the geometry without reflecting the shape's styling. This ignores |
| * the inverse fill nature of the geometry. |
| */ |
| SkRect bounds() const { return fShape.bounds(); } |
| |
| /** |
| * Gets the bounds of the geometry reflecting the shape's styling (ignoring inverse fill |
| * status). |
| */ |
| SkRect styledBounds() const; |
| |
| /** |
| * Is this shape known to be convex, before styling is applied. An unclosed but otherwise |
| * convex path is considered to be closed if they styling reflects a fill and not otherwise. |
| * This is because filling closes all contours in the path. |
| */ |
| bool knownToBeConvex() const { |
| return fShape.convex(fStyle.isSimpleFill()); |
| } |
| |
| /** |
| * Does the shape have a known winding direction. Some degenerate convex shapes may not have |
| * a computable direction, but this is not always a requirement for path renderers so it is |
| * kept separate from knownToBeConvex(). |
| */ |
| bool knownDirection() const { |
| // Assuming this is called after knownToBeConvex(), this should just be relying on |
| // cached convexity and direction and will be cheap. |
| return !fShape.isPath() || |
| SkPathPriv::ComputeFirstDirection(fShape.path()) != SkPathFirstDirection::kUnknown; |
| } |
| |
| /** Is the pre-styled geometry inverse filled? */ |
| bool inverseFilled() const { |
| // Since the path tracks inverted-fillness itself, it should match what was recorded. |
| SkASSERT(!fShape.isPath() || fShape.inverted() == fShape.path().isInverseFillType()); |
| // Dashing ignores inverseness. We should have caught this earlier. skbug.com/5421 |
| SkASSERT(!(fShape.inverted() && this->style().isDashed())); |
| return fShape.inverted(); |
| } |
| |
| /** |
| * Might applying the styling to the geometry produce an inverse fill. The "may" part comes in |
| * because an arbitrary path effect could produce an inverse filled path. In other cases this |
| * can be thought of as "inverseFilledAfterStyling()". |
| */ |
| bool mayBeInverseFilledAfterStyling() const { |
| // An arbitrary path effect can produce an arbitrary output path, which may be inverse |
| // filled. |
| if (this->style().hasNonDashPathEffect()) { |
| return true; |
| } |
| return this->inverseFilled(); |
| } |
| |
| /** |
| * 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 { |
| // This refers to the base shape and does not depend on invertedness. |
| return fShape.closed(); |
| } |
| |
| uint32_t segmentMask() const { |
| // This refers to the base shape and does not depend on invertedness. |
| return fShape.segmentMask(); |
| } |
| |
| /** |
| * Gets the size of the key for the shape represented by this GrStyledShape (ignoring its |
| * styling). A negative value is returned if the shape has no key (shouldn't be cached). |
| */ |
| int unstyledKeySize() const; |
| |
| bool hasUnstyledKey() const { return this->unstyledKeySize() >= 0; } |
| |
| /** |
| * Writes unstyledKeySize() bytes into the provided pointer. Assumes that there is enough |
| * space allocated for the key and that unstyledKeySize() does not return a negative value |
| * for this shape. |
| */ |
| void writeUnstyledKey(uint32_t* key) const; |
| |
| /** |
| * Adds a listener to the *original* path. Typically used to invalidate cached resources when |
| * a path is no longer in-use. If the shape started out as something other than a path, this |
| * does nothing. |
| */ |
| void addGenIDChangeListener(sk_sp<SkIDChangeListener>) const; |
| |
| /** |
| * Helpers that are only exposed for unit tests, to determine if the shape is a path, and get |
| * the generation ID of the *original* path. This is the path that will receive |
| * GenIDChangeListeners added to this shape. |
| */ |
| uint32_t testingOnly_getOriginalGenerationID() const; |
| bool testingOnly_isPath() const; |
| bool testingOnly_isNonVolatilePath() const; |
| |
| /** |
| * Similar to GrShape::simplify but also takes into account style and stroking, possibly |
| * applying the style explicitly to produce a new analytic shape with a simpler style. |
| * Unless "doSimplify" is kNo, this method gets called automatically during construction. |
| */ |
| void simplify(); |
| |
| private: |
| /** Constructor used by the applyStyle() function */ |
| GrStyledShape(const GrStyledShape& parentShape, GrStyle::Apply, SkScalar scale); |
| |
| /** |
| * 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 GrStyledShape& parentShape, GrStyle::Apply, SkScalar scale); |
| |
| /** |
| * As part of the simplification process, some shapes can have stroking trivially evaluated |
| * and form a new geometry with just a fill. |
| */ |
| void simplifyStroke(); |
| |
| /** Gets the path that gen id listeners should be added to. */ |
| const SkPath* originalPathForListeners() const; |
| |
| GrShape fShape; |
| GrStyle fStyle; |
| // Gen ID of the original path (path may be modified or simplified away). |
| int32_t fGenID = 0; |
| bool fClosed = false; |
| bool fSimplified = false; |
| |
| SkTLazy<SkPath> fInheritedPathForListeners; |
| SkAutoSTArray<8, uint32_t> fInheritedKey; |
| }; |
| #endif |
