Line data Source code
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 "SkScalar.h"
12 : #include "SkPoint3.h"
13 : #include "SkTypes.h"
14 :
15 : /** \file SkColor.h
16 :
17 : Types and macros for colors
18 : */
19 :
20 : /** 8-bit type for an alpha value. 0xFF is 100% opaque, 0x00 is 100% transparent.
21 : */
22 : typedef uint8_t SkAlpha;
23 : /** 32 bit ARGB color value, not premultiplied. The color components are always in
24 : a known order. This is different from SkPMColor, which has its bytes in a configuration
25 : dependent order, to match the format of kARGB32 bitmaps. SkColor is the type used to
26 : specify colors in SkPaint and in gradients.
27 : */
28 : typedef uint32_t SkColor;
29 :
30 : /** Return a SkColor value from 8 bit component values
31 : */
32 640 : static inline SkColor SkColorSetARGBInline(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
33 : {
34 640 : SkASSERT(a <= 255 && r <= 255 && g <= 255 && b <= 255);
35 :
36 640 : return (a << 24) | (r << 16) | (g << 8) | (b << 0);
37 : }
38 :
39 : #define SkColorSetARGBMacro(a, r, g, b) \
40 : static_cast<SkColor>( \
41 : (static_cast<U8CPU>(a) << 24) | \
42 : (static_cast<U8CPU>(r) << 16) | \
43 : (static_cast<U8CPU>(g) << 8) | \
44 : (static_cast<U8CPU>(b) << 0))
45 :
46 : /** gcc will generate static initializers for code of this form:
47 : * static const SkColor kMyColor = SkColorSetARGB(0xFF, 0x01, 0x02, 0x03)
48 : * if SkColorSetARGB() is a static inline, but not if it's a macro.
49 : */
50 : #if defined(NDEBUG)
51 : #define SkColorSetARGB(a, r, g, b) SkColorSetARGBMacro(a, r, g, b)
52 : #else
53 : #define SkColorSetARGB(a, r, g, b) SkColorSetARGBInline(a, r, g, b)
54 : #endif
55 :
56 : /** Return a SkColor value from 8 bit component values, with an implied value
57 : of 0xFF for alpha (fully opaque)
58 : */
59 : #define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b)
60 :
61 : /** return the alpha byte from a SkColor value */
62 : #define SkColorGetA(color) (((color) >> 24) & 0xFF)
63 : /** return the red byte from a SkColor value */
64 : #define SkColorGetR(color) (((color) >> 16) & 0xFF)
65 : /** return the green byte from a SkColor value */
66 : #define SkColorGetG(color) (((color) >> 8) & 0xFF)
67 : /** return the blue byte from a SkColor value */
68 : #define SkColorGetB(color) (((color) >> 0) & 0xFF)
69 :
70 0 : static constexpr inline SkColor SkColorSetA(SkColor c, U8CPU a) {
71 0 : return (c & 0x00FFFFFF) | (a << 24);
72 : }
73 :
74 : // common colors
75 :
76 : #define SK_AlphaTRANSPARENT 0x00 //!< transparent SkAlpha value
77 : #define SK_AlphaOPAQUE 0xFF //!< opaque SkAlpha value
78 :
79 : #define SK_ColorTRANSPARENT 0x00000000 //!< transparent SkColor value
80 :
81 : #define SK_ColorBLACK 0xFF000000 //!< black SkColor value
82 : #define SK_ColorDKGRAY 0xFF444444 //!< dark gray SkColor value
83 : #define SK_ColorGRAY 0xFF888888 //!< gray SkColor value
84 : #define SK_ColorLTGRAY 0xFFCCCCCC //!< light gray SkColor value
85 : #define SK_ColorWHITE 0xFFFFFFFF //!< white SkColor value
86 :
87 : #define SK_ColorRED 0xFFFF0000 //!< red SkColor value
88 : #define SK_ColorGREEN 0xFF00FF00 //!< green SkColor value
89 : #define SK_ColorBLUE 0xFF0000FF //!< blue SkColor value
90 : #define SK_ColorYELLOW 0xFFFFFF00 //!< yellow SkColor value
91 : #define SK_ColorCYAN 0xFF00FFFF //!< cyan SkColor value
92 : #define SK_ColorMAGENTA 0xFFFF00FF //!< magenta SkColor value
93 :
94 : ////////////////////////////////////////////////////////////////////////
95 :
96 : /** Convert RGB components to HSV.
97 : hsv[0] is Hue [0 .. 360)
98 : hsv[1] is Saturation [0...1]
99 : hsv[2] is Value [0...1]
100 : @param red red component value [0..255]
101 : @param green green component value [0..255]
102 : @param blue blue component value [0..255]
103 : @param hsv 3 element array which holds the resulting HSV components.
104 : */
105 : SK_API void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3]);
106 :
107 : /** Convert the argb color to its HSV components.
108 : hsv[0] is Hue [0 .. 360)
109 : hsv[1] is Saturation [0...1]
110 : hsv[2] is Value [0...1]
111 : @param color the argb color to convert. Note: the alpha component is ignored.
112 : @param hsv 3 element array which holds the resulting HSV components.
113 : */
114 : static inline void SkColorToHSV(SkColor color, SkScalar hsv[3]) {
115 : SkRGBToHSV(SkColorGetR(color), SkColorGetG(color), SkColorGetB(color), hsv);
116 : }
117 :
118 : /** Convert HSV components to an ARGB color. The alpha component is passed through unchanged.
119 : hsv[0] is Hue [0 .. 360)
120 : hsv[1] is Saturation [0...1]
121 : hsv[2] is Value [0...1]
122 : If hsv values are out of range, they are pinned.
123 : @param alpha the alpha component of the returned argb color.
124 : @param hsv 3 element array which holds the input HSV components.
125 : @return the resulting argb color
126 : */
127 : SK_API SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3]);
128 :
129 : /** Convert HSV components to an ARGB color. The alpha component set to 0xFF.
130 : hsv[0] is Hue [0 .. 360)
131 : hsv[1] is Saturation [0...1]
132 : hsv[2] is Value [0...1]
133 : If hsv values are out of range, they are pinned.
134 : @param hsv 3 element array which holds the input HSV components.
135 : @return the resulting argb color
136 : */
137 : static inline SkColor SkHSVToColor(const SkScalar hsv[3]) {
138 : return SkHSVToColor(0xFF, hsv);
139 : }
140 :
141 : ////////////////////////////////////////////////////////////////////////
142 :
143 : /** 32 bit ARGB color value, premultiplied. The byte order for this value is
144 : configuration dependent, matching the format of kARGB32 bitmaps. This is different
145 : from SkColor, which is nonpremultiplied, and is always in the same byte order.
146 : */
147 : typedef uint32_t SkPMColor;
148 :
149 : /** Return a SkPMColor value from unpremultiplied 8 bit component values
150 : */
151 : SK_API SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
152 : /** Return a SkPMColor value from a SkColor value. This is done by multiplying the color
153 : components by the color's alpha, and by arranging the bytes in a configuration
154 : dependent order, to match the format of kARGB32 bitmaps.
155 : */
156 : SK_API SkPMColor SkPreMultiplyColor(SkColor c);
157 :
158 : /** Define a function pointer type for combining two premultiplied colors
159 : */
160 : typedef SkPMColor (*SkXfermodeProc)(SkPMColor src, SkPMColor dst);
161 :
162 : ///////////////////////////////////////////////////////////////////////////////////////////////////
163 :
164 : struct SkPM4f;
165 :
166 : /*
167 : * The float values are 0...1 unpremultiplied
168 : */
169 : struct SkColor4f {
170 : float fR;
171 : float fG;
172 : float fB;
173 : float fA;
174 :
175 0 : bool operator==(const SkColor4f& other) const {
176 0 : return fA == other.fA && fR == other.fR && fG == other.fG && fB == other.fB;
177 : }
178 0 : bool operator!=(const SkColor4f& other) const {
179 0 : return !(*this == other);
180 : }
181 :
182 81 : const float* vec() const { return &fR; }
183 705 : float* vec() { return &fR; }
184 :
185 : static SkColor4f Pin(float r, float g, float b, float a);
186 : /** Convert to SkColor4f, assuming SkColor is sRGB */
187 : static SkColor4f FromColor(SkColor);
188 : static SkColor4f FromColor3f(SkColor3f, float a);
189 :
190 : SkColor toSkColor() const;
191 :
192 312 : SkColor4f pin() const {
193 312 : return Pin(fR, fG, fB, fA);
194 : }
195 :
196 : SkPM4f premul() const;
197 : };
198 :
199 : #endif
|
