blob: 9f7f630a4f7a2365f2784af52f008f5cff73d8a6 [file] [log] [blame]
bsalomon47cc7692016-04-26 12:56:00 -07001/*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrStyle_DEFINED
9#define GrStyle_DEFINED
10
11#include "GrTypes.h"
12#include "SkPathEffect.h"
13#include "SkStrokeRec.h"
14#include "SkTemplates.h"
15
16/**
17 * Represents the various ways that a GrShape can be styled. It has fill/stroking information
18 * as well as an optional path effect. If the path effect represents dashing, the dashing
19 * information is extracted from the path effect and stored explicitly.
20 *
bsalomon47cc7692016-04-26 12:56:00 -070021 * This will replace GrStrokeInfo as GrShape is deployed.
22 */
23class GrStyle {
24public:
bsalomonfb083272016-05-04 08:27:41 -070025 /**
26 * A style object that represents a fill with no path effect.
27 * TODO: constexpr with C++14
28 */
29 static const GrStyle& SimpleFill() {
30 static const GrStyle kFill(SkStrokeRec::kFill_InitStyle);
31 return kFill;
32 }
33
34 /**
35 * A style object that represents a hairline stroke with no path effect.
36 * TODO: constexpr with C++14
37 */
38 static const GrStyle& SimpleHairline() {
39 static const GrStyle kHairline(SkStrokeRec::kHairline_InitStyle);
40 return kHairline;
bsalomon47cc7692016-04-26 12:56:00 -070041 }
42
bsalomonfb083272016-05-04 08:27:41 -070043 enum class Apply {
44 kPathEffectOnly,
45 kPathEffectAndStrokeRec
46 };
47
48 /**
bsalomon06077562016-05-04 13:50:29 -070049 * Optional flags for computing keys that may remove unnecessary variation in the key due to
50 * style settings that don't affect particular classes of geometry.
51 */
52 enum KeyFlags {
53 // The shape being styled has no open contours.
bsalomon0ae36a22016-07-18 07:31:13 -070054 kClosed_KeyFlag = 0x1,
55 // The shape being styled doesn't have any joins and so isn't affected by join type.
56 kNoJoins_KeyFlag = 0x2
bsalomon06077562016-05-04 13:50:29 -070057 };
58
59 /**
bsalomonfb083272016-05-04 08:27:41 -070060 * Computes the key length for a GrStyle. The return will be negative if it cannot be turned
61 * into a key. This occurs when there is a path effect that is not a dash. The key can
62 * either reflect just the path effect (if one) or the path effect and the strokerec. Note
63 * that a simple fill has a zero sized key.
64 */
bsalomon97fd2d42016-05-09 13:02:01 -070065 static int KeySize(const GrStyle&, Apply, uint32_t flags = 0);
bsalomonfb083272016-05-04 08:27:41 -070066
67 /**
68 * Writes a unique key for the style into the provided buffer. This function assumes the buffer
69 * has room for at least KeySize() values. It assumes that KeySize() returns a non-negative
bsalomon06077562016-05-04 13:50:29 -070070 * value for the combination of GrStyle, Apply and flags params. This is written so that the key
71 * for just dash application followed by the key for the remaining SkStrokeRec is the same as
72 * the key for applying dashing and SkStrokeRec all at once.
bsalomonfb083272016-05-04 08:27:41 -070073 */
bsalomon97fd2d42016-05-09 13:02:01 -070074 static void WriteKey(uint32_t*, const GrStyle&, Apply, SkScalar scale, uint32_t flags = 0);
bsalomonfb083272016-05-04 08:27:41 -070075
76 GrStyle() : GrStyle(SkStrokeRec::kFill_InitStyle) {}
77
78 explicit GrStyle(SkStrokeRec::InitStyle initStyle) : fStrokeRec(initStyle) {}
79
Robert Phillipsf809c1e2017-01-13 11:02:42 -050080 GrStyle(const SkStrokeRec& strokeRec, sk_sp<SkPathEffect> pe) : fStrokeRec(strokeRec) {
81 this->initPathEffect(std::move(pe));
bsalomon47cc7692016-04-26 12:56:00 -070082 }
83
Brian Salomon20aaaee2018-01-02 15:54:42 -050084 GrStyle(const GrStyle& that) = default;
bsalomon47cc7692016-04-26 12:56:00 -070085
86 explicit GrStyle(const SkPaint& paint) : fStrokeRec(paint) {
Robert Phillipsf809c1e2017-01-13 11:02:42 -050087 this->initPathEffect(paint.refPathEffect());
bsalomon47cc7692016-04-26 12:56:00 -070088 }
89
bsalomon6663acf2016-05-10 09:14:17 -070090 explicit GrStyle(const SkPaint& paint, SkPaint::Style overrideStyle)
91 : fStrokeRec(paint, overrideStyle) {
Robert Phillipsf809c1e2017-01-13 11:02:42 -050092 this->initPathEffect(paint.refPathEffect());
bsalomon6663acf2016-05-10 09:14:17 -070093 }
94
bsalomon47cc7692016-04-26 12:56:00 -070095 GrStyle& operator=(const GrStyle& that) {
96 fPathEffect = that.fPathEffect;
97 fDashInfo = that.fDashInfo;
98 fStrokeRec = that.fStrokeRec;
99 return *this;
100 }
bsalomonfb083272016-05-04 08:27:41 -0700101
102 void resetToInitStyle(SkStrokeRec::InitStyle fillOrHairline) {
103 fDashInfo.reset();
104 fPathEffect.reset(nullptr);
105 if (SkStrokeRec::kFill_InitStyle == fillOrHairline) {
106 fStrokeRec.setFillStyle();
107 } else {
108 fStrokeRec.setHairlineStyle();
109 }
110 }
111
112 /** Is this style a fill with no path effect? */
113 bool isSimpleFill() const { return fStrokeRec.isFillStyle() && !fPathEffect; }
114
115 /** Is this style a hairline with no path effect? */
116 bool isSimpleHairline() const { return fStrokeRec.isHairlineStyle() && !fPathEffect; }
117
bsalomon47cc7692016-04-26 12:56:00 -0700118 SkPathEffect* pathEffect() const { return fPathEffect.get(); }
Robert Phillipsf809c1e2017-01-13 11:02:42 -0500119 sk_sp<SkPathEffect> refPathEffect() const { return fPathEffect; }
bsalomon47cc7692016-04-26 12:56:00 -0700120
bsalomonee295642016-06-06 14:01:25 -0700121 bool hasPathEffect() const { return SkToBool(fPathEffect.get()); }
122
bsalomonfb083272016-05-04 08:27:41 -0700123 bool hasNonDashPathEffect() const { return fPathEffect.get() && !this->isDashed(); }
124
bsalomon47cc7692016-04-26 12:56:00 -0700125 bool isDashed() const { return SkPathEffect::kDash_DashType == fDashInfo.fType; }
126 SkScalar dashPhase() const {
127 SkASSERT(this->isDashed());
128 return fDashInfo.fPhase;
129 }
130 int dashIntervalCnt() const {
131 SkASSERT(this->isDashed());
132 return fDashInfo.fIntervals.count();
133 }
134 const SkScalar* dashIntervals() const {
135 SkASSERT(this->isDashed());
136 return fDashInfo.fIntervals.get();
137 }
138
139 const SkStrokeRec& strokeRec() const { return fStrokeRec; }
140
bsalomonfb083272016-05-04 08:27:41 -0700141 /** Hairline or fill styles without path effects make no alterations to a geometry. */
142 bool applies() const {
143 return this->pathEffect() || (!fStrokeRec.isFillStyle() && !fStrokeRec.isHairlineStyle());
144 }
145
bsalomon6663acf2016-05-10 09:14:17 -0700146 static SkScalar MatrixToScaleFactor(const SkMatrix& matrix) {
147 // getMaxScale will return -1 if the matrix has perspective. In that case we can use a scale
148 // factor of 1. This isn't necessarily a good choice and in the future we might consider
149 // taking a bounds here for the perspective case.
150 return SkScalarAbs(matrix.getMaxScale());
151 }
bsalomonfb083272016-05-04 08:27:41 -0700152 /**
153 * Applies just the path effect and returns remaining stroke information. This will fail if
bsalomon97fd2d42016-05-09 13:02:01 -0700154 * there is no path effect. dst may or may not have been overwritten on failure. Scale controls
155 * geometric approximations made by the path effect. It is typically computed from the view
156 * matrix.
bsalomonfb083272016-05-04 08:27:41 -0700157 */
bsalomon1a0b9ed2016-05-06 11:07:03 -0700158 bool SK_WARN_UNUSED_RESULT applyPathEffectToPath(SkPath* dst, SkStrokeRec* remainingStoke,
bsalomon97fd2d42016-05-09 13:02:01 -0700159 const SkPath& src, SkScalar scale) const;
bsalomonfb083272016-05-04 08:27:41 -0700160
bsalomon97fd2d42016-05-09 13:02:01 -0700161 /**
162 * If this succeeds then the result path should be filled or hairlined as indicated by the
163 * returned SkStrokeRec::InitStyle value. Will fail if there is no path effect and the
164 * strokerec doesn't change the geometry. When this fails the outputs may or may not have
165 * been overwritten. Scale controls geometric approximations made by the path effect and
166 * stroker. It is typically computed from the view matrix.
167 */
bsalomon1a0b9ed2016-05-06 11:07:03 -0700168 bool SK_WARN_UNUSED_RESULT applyToPath(SkPath* dst, SkStrokeRec::InitStyle* fillOrHairline,
bsalomon97fd2d42016-05-09 13:02:01 -0700169 const SkPath& src, SkScalar scale) const;
bsalomonfb083272016-05-04 08:27:41 -0700170
171 /** Given bounds of a path compute the bounds of path with the style applied. */
172 void adjustBounds(SkRect* dst, const SkRect& src) const {
173 if (this->pathEffect()) {
174 this->pathEffect()->computeFastBounds(dst, src);
bsalomon9fb42032016-05-13 09:23:38 -0700175 // This may not be the correct SkStrokeRec to use. skbug.com/5299
176 // It happens to work for dashing.
177 SkScalar radius = fStrokeRec.getInflationRadius();
178 dst->outset(radius, radius);
bsalomonfb083272016-05-04 08:27:41 -0700179 } else {
180 SkScalar radius = fStrokeRec.getInflationRadius();
181 *dst = src.makeOutset(radius, radius);
182 }
183 }
184
bsalomon47cc7692016-04-26 12:56:00 -0700185private:
Robert Phillipsf809c1e2017-01-13 11:02:42 -0500186 void initPathEffect(sk_sp<SkPathEffect> pe);
bsalomon47cc7692016-04-26 12:56:00 -0700187
188 struct DashInfo {
bsalomonfb083272016-05-04 08:27:41 -0700189 DashInfo() : fType(SkPathEffect::kNone_DashType) {}
Brian Salomon20aaaee2018-01-02 15:54:42 -0500190 DashInfo(const DashInfo& that) { *this = that; }
bsalomon47cc7692016-04-26 12:56:00 -0700191 DashInfo& operator=(const DashInfo& that) {
192 fType = that.fType;
193 fPhase = that.fPhase;
194 fIntervals.reset(that.fIntervals.count());
benjaminwagnerd9cca4a2016-05-04 11:06:19 -0700195 sk_careful_memcpy(fIntervals.get(), that.fIntervals.get(),
196 sizeof(SkScalar) * that.fIntervals.count());
bsalomon47cc7692016-04-26 12:56:00 -0700197 return *this;
198 }
bsalomonfb083272016-05-04 08:27:41 -0700199 void reset() {
200 fType = SkPathEffect::kNone_DashType;
201 fIntervals.reset(0);
202 }
bsalomon47cc7692016-04-26 12:56:00 -0700203 SkPathEffect::DashType fType;
204 SkScalar fPhase;
205 SkAutoSTArray<4, SkScalar> fIntervals;
206 };
207
bsalomon398e3f42016-06-13 10:22:48 -0700208 bool applyPathEffect(SkPath* dst, SkStrokeRec* strokeRec, const SkPath& src) const;
209
bsalomon47cc7692016-04-26 12:56:00 -0700210 SkStrokeRec fStrokeRec;
211 sk_sp<SkPathEffect> fPathEffect;
212 DashInfo fDashInfo;
213};
214
215#endif