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 SkColor_DEFINED
9 #define SkColor_DEFINED
10
11 #include "include/core/SkImageInfo.h"
12 #include "include/core/SkScalar.h"
13 #include "include/core/SkTypes.h"
14
15 #include <array>
16
17 /** \file SkColor.h
18
19 Types, consts, functions, and macros for colors.
20 */
21
22 /** 8-bit type for an alpha value. 255 is 100% opaque, zero is 100% transparent.
23 */
24 typedef uint8_t SkAlpha;
25
26 /** 32-bit ARGB color value, unpremultiplied. Color components are always in
27 a known order. This is different from SkPMColor, which has its bytes in a configuration
28 dependent order, to match the format of kBGRA_8888_SkColorType bitmaps. SkColor
29 is the type used to specify colors in SkPaint and in gradients.
30
31 Color that is premultiplied has the same component values as color
32 that is unpremultiplied if alpha is 255, fully opaque, although may have the
33 component values in a different order.
34 */
35 typedef uint32_t SkColor;
36
37 /** Returns color value from 8-bit component values. Asserts if SK_DEBUG is defined
38 if a, r, g, or b exceed 255. Since color is unpremultiplied, a may be smaller
39 than the largest of r, g, and b.
40
41 @param a amount of alpha, from fully transparent (0) to fully opaque (255)
42 @param r amount of red, from no red (0) to full red (255)
43 @param g amount of green, from no green (0) to full green (255)
44 @param b amount of blue, from no blue (0) to full blue (255)
45 @return color and alpha, unpremultiplied
46 */
SkColorSetARGB(U8CPU a,U8CPU r,U8CPU g,U8CPU b)47 static constexpr inline SkColor SkColorSetARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
48 return SkASSERT(a <= 255 && r <= 255 && g <= 255 && b <= 255),
49 (a << 24) | (r << 16) | (g << 8) | (b << 0);
50 }
51
52 /** Returns color value from 8-bit component values, with alpha set
53 fully opaque to 255.
54 */
55 #define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b)
56
57 /** Returns alpha byte from color value.
58 */
59 #define SkColorGetA(color) (((color) >> 24) & 0xFF)
60
61 /** Returns red component of color, from zero to 255.
62 */
63 #define SkColorGetR(color) (((color) >> 16) & 0xFF)
64
65 /** Returns green component of color, from zero to 255.
66 */
67 #define SkColorGetG(color) (((color) >> 8) & 0xFF)
68
69 /** Returns blue component of color, from zero to 255.
70 */
71 #define SkColorGetB(color) (((color) >> 0) & 0xFF)
72
73 /** Returns unpremultiplied color with red, blue, and green set from c; and alpha set
74 from a. Alpha component of c is ignored and is replaced by a in result.
75
76 @param c packed RGB, eight bits per component
77 @param a alpha: transparent at zero, fully opaque at 255
78 @return color with transparency
79 */
SkColorSetA(SkColor c,U8CPU a)80 static constexpr inline SkColor SK_WARN_UNUSED_RESULT SkColorSetA(SkColor c, U8CPU a) {
81 return (c & 0x00FFFFFF) | (a << 24);
82 }
83
84 /** Represents fully transparent SkAlpha value. SkAlpha ranges from zero,
85 fully transparent; to 255, fully opaque.
86 */
87 constexpr SkAlpha SK_AlphaTRANSPARENT = 0x00;
88
89 /** Represents fully opaque SkAlpha value. SkAlpha ranges from zero,
90 fully transparent; to 255, fully opaque.
91 */
92 constexpr SkAlpha SK_AlphaOPAQUE = 0xFF;
93
94 /** Represents fully transparent SkColor. May be used to initialize a destination
95 containing a mask or a non-rectangular image.
96 */
97 constexpr SkColor SK_ColorTRANSPARENT = SkColorSetARGB(0x00, 0x00, 0x00, 0x00);
98
99 /** Represents fully opaque black.
100 */
101 constexpr SkColor SK_ColorBLACK = SkColorSetARGB(0xFF, 0x00, 0x00, 0x00);
102
103 /** Represents fully opaque dark gray.
104 Note that SVG dark gray is equivalent to 0xFFA9A9A9.
105 */
106 constexpr SkColor SK_ColorDKGRAY = SkColorSetARGB(0xFF, 0x44, 0x44, 0x44);
107
108 /** Represents fully opaque gray.
109 Note that HTML gray is equivalent to 0xFF808080.
110 */
111 constexpr SkColor SK_ColorGRAY = SkColorSetARGB(0xFF, 0x88, 0x88, 0x88);
112
113 /** Represents fully opaque light gray. HTML silver is equivalent to 0xFFC0C0C0.
114 Note that SVG light gray is equivalent to 0xFFD3D3D3.
115 */
116 constexpr SkColor SK_ColorLTGRAY = SkColorSetARGB(0xFF, 0xCC, 0xCC, 0xCC);
117
118 /** Represents fully opaque white.
119 */
120 constexpr SkColor SK_ColorWHITE = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
121
122 /** Represents fully opaque red.
123 */
124 constexpr SkColor SK_ColorRED = SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00);
125
126 /** Represents fully opaque green. HTML lime is equivalent.
127 Note that HTML green is equivalent to 0xFF008000.
128 */
129 constexpr SkColor SK_ColorGREEN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0x00);
130
131 /** Represents fully opaque blue.
132 */
133 constexpr SkColor SK_ColorBLUE = SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF);
134
135 /** Represents fully opaque yellow.
136 */
137 constexpr SkColor SK_ColorYELLOW = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0x00);
138
139 /** Represents fully opaque cyan. HTML aqua is equivalent.
140 */
141 constexpr SkColor SK_ColorCYAN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0xFF);
142
143 /** Represents fully opaque magenta. HTML fuchsia is equivalent.
144 */
145 constexpr SkColor SK_ColorMAGENTA = SkColorSetARGB(0xFF, 0xFF, 0x00, 0xFF);
146
147 /** Converts RGB to its HSV components.
148 hsv[0] contains hsv hue, a value from zero to less than 360.
149 hsv[1] contains hsv saturation, a value from zero to one.
150 hsv[2] contains hsv value, a value from zero to one.
151
152 @param red red component value from zero to 255
153 @param green green component value from zero to 255
154 @param blue blue component value from zero to 255
155 @param hsv three element array which holds the resulting HSV components
156 */
157 SK_API void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3]);
158
159 /** Converts ARGB to its HSV components. Alpha in ARGB is ignored.
160 hsv[0] contains hsv hue, and is assigned a value from zero to less than 360.
161 hsv[1] contains hsv saturation, a value from zero to one.
162 hsv[2] contains hsv value, a value from zero to one.
163
164 @param color ARGB color to convert
165 @param hsv three element array which holds the resulting HSV components
166 */
SkColorToHSV(SkColor color,SkScalar hsv[3])167 static inline void SkColorToHSV(SkColor color, SkScalar hsv[3]) {
168 SkRGBToHSV(SkColorGetR(color), SkColorGetG(color), SkColorGetB(color), hsv);
169 }
170
171 /** Converts HSV components to an ARGB color. Alpha is passed through unchanged.
172 hsv[0] represents hsv hue, an angle from zero to less than 360.
173 hsv[1] represents hsv saturation, and varies from zero to one.
174 hsv[2] represents hsv value, and varies from zero to one.
175
176 Out of range hsv values are pinned.
177
178 @param alpha alpha component of the returned ARGB color
179 @param hsv three element array which holds the input HSV components
180 @return ARGB equivalent to HSV
181 */
182 SK_API SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3]);
183
184 /** Converts HSV components to an ARGB color. Alpha is set to 255.
185 hsv[0] represents hsv hue, an angle from zero to less than 360.
186 hsv[1] represents hsv saturation, and varies from zero to one.
187 hsv[2] represents hsv value, and varies from zero to one.
188
189 Out of range hsv values are pinned.
190
191 @param hsv three element array which holds the input HSV components
192 @return RGB equivalent to HSV
193 */
SkHSVToColor(const SkScalar hsv[3])194 static inline SkColor SkHSVToColor(const SkScalar hsv[3]) {
195 return SkHSVToColor(0xFF, hsv);
196 }
197
198 /** 32-bit ARGB color value, premultiplied. The byte order for this value is
199 configuration dependent, matching the format of kBGRA_8888_SkColorType bitmaps.
200 This is different from SkColor, which is unpremultiplied, and is always in the
201 same byte order.
202 */
203 typedef uint32_t SkPMColor;
204
205 /** Returns a SkPMColor value from unpremultiplied 8-bit component values.
206
207 @param a amount of alpha, from fully transparent (0) to fully opaque (255)
208 @param r amount of red, from no red (0) to full red (255)
209 @param g amount of green, from no green (0) to full green (255)
210 @param b amount of blue, from no blue (0) to full blue (255)
211 @return premultiplied color
212 */
213 SK_API SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
214
215 /** Returns pmcolor closest to color c. Multiplies c RGB components by the c alpha,
216 and arranges the bytes to match the format of kN32_SkColorType.
217
218 @param c unpremultiplied ARGB color
219 @return premultiplied color
220 */
221 SK_API SkPMColor SkPreMultiplyColor(SkColor c);
222
223 /** \enum SkColorChannel
224 Describes different color channels one can manipulate
225 */
226 enum class SkColorChannel {
227 kR, // the red channel
228 kG, // the green channel
229 kB, // the blue channel
230 kA, // the alpha channel
231
232 kLastEnum = kA,
233 };
234
235 /** Used to represent the channels available in a color type or texture format as a mask. */
236 enum SkColorChannelFlag : uint32_t {
237 kRed_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kR),
238 kGreen_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kG),
239 kBlue_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kB),
240 kAlpha_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kA),
241 kGray_SkColorChannelFlag = 0x10,
242 // Convenience values
243 kGrayAlpha_SkColorChannelFlags = kGray_SkColorChannelFlag | kAlpha_SkColorChannelFlag,
244 kRG_SkColorChannelFlags = kRed_SkColorChannelFlag | kGreen_SkColorChannelFlag,
245 kRGB_SkColorChannelFlags = kRG_SkColorChannelFlags | kBlue_SkColorChannelFlag,
246 kRGBA_SkColorChannelFlags = kRGB_SkColorChannelFlags | kAlpha_SkColorChannelFlag,
247 };
248 static_assert(0 == (kGray_SkColorChannelFlag & kRGBA_SkColorChannelFlags), "bitfield conflict");
249
250 /** \struct SkRGBA4f
251 RGBA color value, holding four floating point components. Color components are always in
252 a known order. kAT determines if the SkRGBA4f's R, G, and B components are premultiplied
253 by alpha or not.
254
255 Skia's public API always uses unpremultiplied colors, which can be stored as
256 SkRGBA4f<kUnpremul_SkAlphaType>. For convenience, this type can also be referred to
257 as SkColor4f.
258 */
259 template <SkAlphaType kAT>
260 struct SkRGBA4f {
261 float fR; //!< red component
262 float fG; //!< green component
263 float fB; //!< blue component
264 float fA; //!< alpha component
265
266 /** Compares SkRGBA4f with other, and returns true if all components are equal.
267
268 @param other SkRGBA4f to compare
269 @return true if SkRGBA4f equals other
270 */
271 bool operator==(const SkRGBA4f& other) const {
272 return fA == other.fA && fR == other.fR && fG == other.fG && fB == other.fB;
273 }
274
275 /** Compares SkRGBA4f with other, and returns true if not all components are equal.
276
277 @param other SkRGBA4f to compare
278 @return true if SkRGBA4f is not equal to other
279 */
280 bool operator!=(const SkRGBA4f& other) const {
281 return !(*this == other);
282 }
283
284 /** Returns SkRGBA4f multiplied by scale.
285
286 @param scale value to multiply by
287 @return SkRGBA4f as (fR * scale, fG * scale, fB * scale, fA * scale)
288 */
289 SkRGBA4f operator*(float scale) const {
290 return { fR * scale, fG * scale, fB * scale, fA * scale };
291 }
292
293 /** Returns SkRGBA4f multiplied component-wise by scale.
294
295 @param scale SkRGBA4f to multiply by
296 @return SkRGBA4f as (fR * scale.fR, fG * scale.fG, fB * scale.fB, fA * scale.fA)
297 */
298 SkRGBA4f operator*(const SkRGBA4f& scale) const {
299 return { fR * scale.fR, fG * scale.fG, fB * scale.fB, fA * scale.fA };
300 }
301
302 /** Returns a pointer to components of SkRGBA4f, for array access.
303
304 @return pointer to array [fR, fG, fB, fA]
305 */
vecSkRGBA4f306 const float* vec() const { return &fR; }
307
308 /** Returns a pointer to components of SkRGBA4f, for array access.
309
310 @return pointer to array [fR, fG, fB, fA]
311 */
vecSkRGBA4f312 float* vec() { return &fR; }
313
314 /** As a std::array<float, 4> */
arraySkRGBA4f315 std::array<float, 4> array() const { return {fR, fG, fB, fA}; }
316
317 /** Returns one component. Asserts if index is out of range and SK_DEBUG is defined.
318
319 @param index one of: 0 (fR), 1 (fG), 2 (fB), 3 (fA)
320 @return value corresponding to index
321 */
322 float operator[](int index) const {
323 SkASSERT(index >= 0 && index < 4);
324 return this->vec()[index];
325 }
326
327 /** Returns one component. Asserts if index is out of range and SK_DEBUG is defined.
328
329 @param index one of: 0 (fR), 1 (fG), 2 (fB), 3 (fA)
330 @return value corresponding to index
331 */
332 float& operator[](int index) {
333 SkASSERT(index >= 0 && index < 4);
334 return this->vec()[index];
335 }
336
337 /** Returns true if SkRGBA4f is an opaque color. Asserts if fA is out of range and
338 SK_DEBUG is defined.
339
340 @return true if SkRGBA4f is opaque
341 */
isOpaqueSkRGBA4f342 bool isOpaque() const {
343 SkASSERT(fA <= 1.0f && fA >= 0.0f);
344 return fA == 1.0f;
345 }
346
347 /** Returns true if all channels are in [0, 1]. */
fitsInBytesSkRGBA4f348 bool fitsInBytes() const {
349 SkASSERT(fA >= 0.0f && fA <= 1.0f);
350 return fR >= 0.0f && fR <= 1.0f &&
351 fG >= 0.0f && fG <= 1.0f &&
352 fB >= 0.0f && fB <= 1.0f;
353 }
354
355 /** Returns closest SkRGBA4f to SkColor. Only allowed if SkRGBA4f is unpremultiplied.
356
357 @param color Color with Alpha, red, blue, and green components
358 @return SkColor as SkRGBA4f
359
360 example: https://fiddle.skia.org/c/@RGBA4f_FromColor
361 */
362 static SkRGBA4f FromColor(SkColor color); // impl. depends on kAT
363
364 /** Returns closest SkColor to SkRGBA4f. Only allowed if SkRGBA4f is unpremultiplied.
365
366 @return color as SkColor
367
368 example: https://fiddle.skia.org/c/@RGBA4f_toSkColor
369 */
370 SkColor toSkColor() const; // impl. depends on kAT
371
372 /** Returns closest SkRGBA4f to SkPMColor. Only allowed if SkRGBA4f is premultiplied.
373
374 @return SkPMColor as SkRGBA4f
375 */
376 static SkRGBA4f FromPMColor(SkPMColor); // impl. depends on kAT
377
378 /** Returns SkRGBA4f premultiplied by alpha. Asserts at compile time if SkRGBA4f is
379 already premultiplied.
380
381 @return premultiplied color
382 */
premulSkRGBA4f383 SkRGBA4f<kPremul_SkAlphaType> premul() const {
384 static_assert(kAT == kUnpremul_SkAlphaType, "");
385 return { fR * fA, fG * fA, fB * fA, fA };
386 }
387
388 /** Returns SkRGBA4f unpremultiplied by alpha. Asserts at compile time if SkRGBA4f is
389 already unpremultiplied.
390
391 @return unpremultiplied color
392 */
unpremulSkRGBA4f393 SkRGBA4f<kUnpremul_SkAlphaType> unpremul() const {
394 static_assert(kAT == kPremul_SkAlphaType, "");
395
396 if (fA == 0.0f) {
397 return { 0, 0, 0, 0 };
398 } else {
399 float invAlpha = 1 / fA;
400 return { fR * invAlpha, fG * invAlpha, fB * invAlpha, fA };
401 }
402 }
403
404 // This produces bytes in RGBA order (eg GrColor). Impl. is the same, regardless of kAT
405 uint32_t toBytes_RGBA() const;
406 static SkRGBA4f FromBytes_RGBA(uint32_t color);
407
makeOpaqueSkRGBA4f408 SkRGBA4f makeOpaque() const {
409 return { fR, fG, fB, 1.0f };
410 }
411 };
412
413 /** \struct SkColor4f
414 RGBA color value, holding four floating point components. Color components are always in
415 a known order, and are unpremultiplied.
416
417 This is a specialization of SkRGBA4f. For details, @see SkRGBA4f.
418 */
419 using SkColor4f = SkRGBA4f<kUnpremul_SkAlphaType>;
420
421 template <> SK_API SkColor4f SkColor4f::FromColor(SkColor);
422 template <> SK_API SkColor SkColor4f::toSkColor() const;
423
424 namespace SkColors {
425 constexpr SkColor4f kTransparent = {0, 0, 0, 0};
426 constexpr SkColor4f kBlack = {0, 0, 0, 1};
427 constexpr SkColor4f kDkGray = {0.25f, 0.25f, 0.25f, 1};
428 constexpr SkColor4f kGray = {0.50f, 0.50f, 0.50f, 1};
429 constexpr SkColor4f kLtGray = {0.75f, 0.75f, 0.75f, 1};
430 constexpr SkColor4f kWhite = {1, 1, 1, 1};
431 constexpr SkColor4f kRed = {1, 0, 0, 1};
432 constexpr SkColor4f kGreen = {0, 1, 0, 1};
433 constexpr SkColor4f kBlue = {0, 0, 1, 1};
434 constexpr SkColor4f kYellow = {1, 1, 0, 1};
435 constexpr SkColor4f kCyan = {0, 1, 1, 1};
436 constexpr SkColor4f kMagenta = {1, 0, 1, 1};
437 } // namespace SkColors
438 #endif
439