1/*
2 * Copyright 2006 The Android Open Source Project
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 SkGradientShader_DEFINED
9#define SkGradientShader_DEFINED
10
11#include "SkShader.h"
12
13/** \class SkGradientShader
14
15    SkGradientShader hosts factories for creating subclasses of SkShader that
16    render linear and radial gradients.
17*/
18class SK_API SkGradientShader {
19public:
20    enum Flags {
21        /** By default gradients will interpolate their colors in unpremul space
22         *  and then premultiply each of the results. By setting this flag, the
23         *  gradients will premultiply their colors first, and then interpolate
24         *  between them.
25         */
26        kInterpolateColorsInPremul_Flag = 1 << 0,
27    };
28
29    /** Returns a shader that generates a linear gradient between the two specified points.
30        <p />
31        @param  pts     The start and end points for the gradient.
32        @param  colors  The array[count] of colors, to be distributed between the two points
33        @param  pos     May be NULL. array[count] of SkScalars, or NULL, of the relative position of
34                        each corresponding color in the colors array. If this is NULL,
35                        the the colors are distributed evenly between the start and end point.
36                        If this is not null, the values must begin with 0, end with 1.0, and
37                        intermediate values must be strictly increasing.
38        @param  count   Must be >=2. The number of colors (and pos if not NULL) entries.
39        @param  mode    The tiling mode
40    */
41    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
42                                      const SkColor colors[], const SkScalar pos[], int count,
43                                      SkShader::TileMode mode,
44                                      uint32_t flags, const SkMatrix* localMatrix);
45    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
46                                      const SkColor colors[], const SkScalar pos[], int count,
47                                      SkShader::TileMode mode) {
48        return MakeLinear(pts, colors, pos, count, mode, 0, nullptr);
49    }
50
51    /** Returns a shader that generates a linear gradient between the two specified points.
52        <p />
53        @param  pts     The start and end points for the gradient.
54        @param  colors  The array[count] of colors, to be distributed between the two points
55        @param  pos     May be NULL. array[count] of SkScalars, or NULL, of the relative position of
56                        each corresponding color in the colors array. If this is NULL,
57                        the the colors are distributed evenly between the start and end point.
58                        If this is not null, the values must begin with 0, end with 1.0, and
59                        intermediate values must be strictly increasing.
60        @param  count   Must be >=2. The number of colors (and pos if not NULL) entries.
61        @param  mode    The tiling mode
62    */
63    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
64                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
65                                      const SkScalar pos[], int count, SkShader::TileMode mode,
66                                      uint32_t flags, const SkMatrix* localMatrix);
67    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
68                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
69                                      const SkScalar pos[], int count, SkShader::TileMode mode) {
70        return MakeLinear(pts, colors, std::move(colorSpace), pos, count, mode, 0, nullptr);
71    }
72
73    /** Returns a shader that generates a radial gradient given the center and radius.
74        <p />
75        @param  center  The center of the circle for this gradient
76        @param  radius  Must be positive. The radius of the circle for this gradient
77        @param  colors  The array[count] of colors, to be distributed between the center and edge of the circle
78        @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
79                        each corresponding color in the colors array. If this is NULL,
80                        the the colors are distributed evenly between the center and edge of the circle.
81                        If this is not null, the values must begin with 0, end with 1.0, and
82                        intermediate values must be strictly increasing.
83        @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
84        @param  mode    The tiling mode
85    */
86    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
87                                      const SkColor colors[], const SkScalar pos[], int count,
88                                      SkShader::TileMode mode,
89                                      uint32_t flags, const SkMatrix* localMatrix);
90    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
91                                      const SkColor colors[], const SkScalar pos[], int count,
92                                      SkShader::TileMode mode) {
93        return MakeRadial(center, radius, colors, pos, count, mode, 0, nullptr);
94    }
95
96    /** Returns a shader that generates a radial gradient given the center and radius.
97        <p />
98        @param  center  The center of the circle for this gradient
99        @param  radius  Must be positive. The radius of the circle for this gradient
100        @param  colors  The array[count] of colors, to be distributed between the center and edge of the circle
101        @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
102                        each corresponding color in the colors array. If this is NULL,
103                        the the colors are distributed evenly between the center and edge of the circle.
104                        If this is not null, the values must begin with 0, end with 1.0, and
105                        intermediate values must be strictly increasing.
106        @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
107        @param  mode    The tiling mode
108    */
109    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
110                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
111                                      const SkScalar pos[], int count, SkShader::TileMode mode,
112                                      uint32_t flags, const SkMatrix* localMatrix);
113    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
114                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
115                                      const SkScalar pos[], int count, SkShader::TileMode mode) {
116        return MakeRadial(center, radius, colors, std::move(colorSpace), pos, count, mode,
117                          0, nullptr);
118    }
119
120    /**
121     *  Returns a shader that generates a conical gradient given two circles, or
122     *  returns NULL if the inputs are invalid. The gradient interprets the
123     *  two circles according to the following HTML spec.
124     *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
125     */
126    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
127                                               const SkPoint& end, SkScalar endRadius,
128                                               const SkColor colors[], const SkScalar pos[],
129                                               int count, SkShader::TileMode mode,
130                                               uint32_t flags, const SkMatrix* localMatrix);
131    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
132                                               const SkPoint& end, SkScalar endRadius,
133                                               const SkColor colors[], const SkScalar pos[],
134                                               int count, SkShader::TileMode mode) {
135        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode,
136                                   0, nullptr);
137    }
138
139    /**
140     *  Returns a shader that generates a conical gradient given two circles, or
141     *  returns NULL if the inputs are invalid. The gradient interprets the
142     *  two circles according to the following HTML spec.
143     *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
144     */
145    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
146                                               const SkPoint& end, SkScalar endRadius,
147                                               const SkColor4f colors[],
148                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
149                                               int count, SkShader::TileMode mode,
150                                               uint32_t flags, const SkMatrix* localMatrix);
151    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
152                                               const SkPoint& end, SkScalar endRadius,
153                                               const SkColor4f colors[],
154                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
155                                               int count, SkShader::TileMode mode) {
156        return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
157                                   std::move(colorSpace), pos, count, mode, 0, nullptr);
158    }
159
160    /** Returns a shader that generates a sweep gradient given a center.
161        <p />
162        @param  cx         The X coordinate of the center of the sweep
163        @param  cx         The Y coordinate of the center of the sweep
164        @param  colors     The array[count] of colors, to be distributed around the center, within
165                           the gradient angle range.
166        @param  pos        May be NULL. The array[count] of SkScalars, or NULL, of the relative
167                           position of each corresponding color in the colors array. If this is
168                           NULL, then the colors are distributed evenly within the angular range.
169                           If this is not null, the values must begin with 0, end with 1.0, and
170                           intermediate values must be strictly increasing.
171        @param  count      Must be >= 2. The number of colors (and pos if not NULL) entries
172        @param  mode       Tiling mode: controls drawing outside of the gradient angular range.
173        @param  startAngle Start of the angular range, corresponding to pos == 0.
174        @param  endAngle   End of the angular range, corresponding to pos == 1.
175    */
176    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
177                                     const SkColor colors[], const SkScalar pos[], int count,
178                                     SkShader::TileMode mode,
179                                     SkScalar startAngle, SkScalar endAngle,
180                                     uint32_t flags, const SkMatrix* localMatrix);
181    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
182                                     const SkColor colors[], const SkScalar pos[], int count,
183                                     uint32_t flags, const SkMatrix* localMatrix) {
184        return MakeSweep(cx, cy, colors, pos, count, SkShader::kClamp_TileMode, 0, 360, flags,
185                         localMatrix);
186    }
187    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
188                                     const SkColor colors[], const SkScalar pos[], int count) {
189        return MakeSweep(cx, cy, colors, pos, count, 0, nullptr);
190    }
191
192    /** Returns a shader that generates a sweep gradient given a center.
193        <p />
194        @param  cx         The X coordinate of the center of the sweep
195        @param  cx         The Y coordinate of the center of the sweep
196        @param  colors     The array[count] of colors, to be distributed around the center, within
197                           the gradient angle range.
198        @param  pos        May be NULL. The array[count] of SkScalars, or NULL, of the relative
199                           position of each corresponding color in the colors array. If this is
200                           NULL, then the colors are distributed evenly within the angular range.
201                           If this is not null, the values must begin with 0, end with 1.0, and
202                           intermediate values must be strictly increasing.
203        @param  count      Must be >= 2. The number of colors (and pos if not NULL) entries
204        @param  mode       Tiling mode: controls drawing outside of the gradient angular range.
205        @param  startAngle Start of the angular range, corresponding to pos == 0.
206        @param  endAngle   End of the angular range, corresponding to pos == 1.
207    */
208    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
209                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
210                                     const SkScalar pos[], int count,
211                                     SkShader::TileMode mode,
212                                     SkScalar startAngle, SkScalar endAngle,
213                                     uint32_t flags, const SkMatrix* localMatrix);
214    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
215                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
216                                     const SkScalar pos[], int count,
217                                     uint32_t flags, const SkMatrix* localMatrix) {
218        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count,
219                         SkShader::kClamp_TileMode, 0, 360, flags, localMatrix);
220    }
221    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
222                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
223                                     const SkScalar pos[], int count) {
224        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, 0, nullptr);
225    }
226
227    SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
228};
229
230#endif
231