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, NULL);
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, NULL);
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, NULL);
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, 0, NULL);
117    }
118
119    /**
120     *  Returns a shader that generates a conical gradient given two circles, or
121     *  returns NULL if the inputs are invalid. The gradient interprets the
122     *  two circles according to the following HTML spec.
123     *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
124     */
125    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
126                                               const SkPoint& end, SkScalar endRadius,
127                                               const SkColor colors[], const SkScalar pos[],
128                                               int count, SkShader::TileMode mode,
129                                               uint32_t flags, const SkMatrix* localMatrix);
130    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
131                                               const SkPoint& end, SkScalar endRadius,
132                                               const SkColor colors[], const SkScalar pos[],
133                                               int count, SkShader::TileMode mode) {
134        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode,
135                                   0, NULL);
136    }
137
138    /**
139     *  Returns a shader that generates a conical gradient given two circles, or
140     *  returns NULL if the inputs are invalid. The gradient interprets the
141     *  two circles according to the following HTML spec.
142     *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
143     */
144    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
145                                               const SkPoint& end, SkScalar endRadius,
146                                               const SkColor4f colors[],
147                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
148                                               int count, SkShader::TileMode mode,
149                                               uint32_t flags, const SkMatrix* localMatrix);
150    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
151                                               const SkPoint& end, SkScalar endRadius,
152                                               const SkColor4f colors[],
153                                               sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
154                                               int count, SkShader::TileMode mode) {
155        return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
156                                   std::move(colorSpace), pos, count, mode, 0, NULL);
157    }
158
159    /** Returns a shader that generates a sweep gradient given a center.
160        <p />
161        @param  cx      The X coordinate of the center of the sweep
162        @param  cx      The Y coordinate of the center of the sweep
163        @param  colors  The array[count] of colors, to be distributed around the center.
164        @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
165                        each corresponding color in the colors array. If this is NULL,
166                        the the colors are distributed evenly between the center and edge of the circle.
167                        If this is not null, the values must begin with 0, end with 1.0, and
168                        intermediate values must be strictly increasing.
169        @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
170    */
171    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
172                                     const SkColor colors[], const SkScalar pos[], int count,
173                                     uint32_t flags, const SkMatrix* localMatrix);
174    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
175                                     const SkColor colors[], const SkScalar pos[], int count) {
176        return MakeSweep(cx, cy, colors, pos, count, 0, NULL);
177    }
178
179    /** Returns a shader that generates a sweep gradient given a center.
180        <p />
181        @param  cx      The X coordinate of the center of the sweep
182        @param  cx      The Y coordinate of the center of the sweep
183        @param  colors  The array[count] of colors, to be distributed around the center.
184        @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
185                        each corresponding color in the colors array. If this is NULL,
186                        the the colors are distributed evenly between the center and edge of the circle.
187                        If this is not null, the values must begin with 0, end with 1.0, and
188                        intermediate values must be strictly increasing.
189        @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
190    */
191    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
192                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
193                                     const SkScalar pos[], int count,
194                                     uint32_t flags, const SkMatrix* localMatrix);
195    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
196                                     const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
197                                     const SkScalar pos[], int count) {
198        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, 0, NULL);
199    }
200
201    SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
202};
203
204#endif
205