11 #ifndef GrColor_DEFINED
12 #define GrColor_DEFINED
16 #include "SkColorPriv.h"
17 #include "SkUnPreMultiply.h"
23 typedef uint32_t GrColor;
30 #define GrColor_SHIFT_R 24
31 #define GrColor_SHIFT_G 16
32 #define GrColor_SHIFT_B 8
33 #define GrColor_SHIFT_A 0
35 #define GrColor_SHIFT_R 0
36 #define GrColor_SHIFT_G 8
37 #define GrColor_SHIFT_B 16
38 #define GrColor_SHIFT_A 24
44 static inline GrColor GrColorPackRGBA(
unsigned r,
unsigned g,
unsigned b,
unsigned a) {
45 SkASSERT((uint8_t)r == r);
46 SkASSERT((uint8_t)g == g);
47 SkASSERT((uint8_t)b == b);
48 SkASSERT((uint8_t)a == a);
49 return (r << GrColor_SHIFT_R) |
50 (g << GrColor_SHIFT_G) |
51 (b << GrColor_SHIFT_B) |
52 (a << GrColor_SHIFT_A);
58 static inline GrColor GrColorPackA4(
unsigned a) {
59 SkASSERT((uint8_t)a == a);
60 return (a << GrColor_SHIFT_R) |
61 (a << GrColor_SHIFT_G) |
62 (a << GrColor_SHIFT_B) |
63 (a << GrColor_SHIFT_A);
68 #define GrColorUnpackR(color) (((color) >> GrColor_SHIFT_R) & 0xFF)
69 #define GrColorUnpackG(color) (((color) >> GrColor_SHIFT_G) & 0xFF)
70 #define GrColorUnpackB(color) (((color) >> GrColor_SHIFT_B) & 0xFF)
71 #define GrColorUnpackA(color) (((color) >> GrColor_SHIFT_A) & 0xFF)
77 #define GrColor_ILLEGAL (~(0xFF << GrColor_SHIFT_A))
79 #define GrColor_WHITE 0xFFFFFFFF
80 #define GrColor_TRANSPARENT_BLACK 0x0
85 static inline void GrColorIsPMAssert(GrColor SkDEBUGCODE(c)) {
87 unsigned a = GrColorUnpackA(c);
88 unsigned r = GrColorUnpackR(c);
89 unsigned g = GrColorUnpackG(c);
90 unsigned b = GrColorUnpackB(c);
99 static inline GrColor GrInvertColor(GrColor c) {
100 U8CPU a = GrColorUnpackA(c);
101 U8CPU r = GrColorUnpackR(c);
102 U8CPU g = GrColorUnpackG(c);
103 U8CPU b = GrColorUnpackB(c);
104 return GrColorPackRGBA(0xff - r, 0xff - g, 0xff - b, 0xff - a);
107 static inline GrColor GrColorMul(GrColor c0, GrColor c1) {
108 U8CPU r = SkMulDiv255Round(GrColorUnpackR(c0), GrColorUnpackR(c1));
109 U8CPU g = SkMulDiv255Round(GrColorUnpackG(c0), GrColorUnpackG(c1));
110 U8CPU b = SkMulDiv255Round(GrColorUnpackB(c0), GrColorUnpackB(c1));
111 U8CPU a = SkMulDiv255Round(GrColorUnpackA(c0), GrColorUnpackA(c1));
112 return GrColorPackRGBA(r, g, b, a);
115 static inline GrColor GrColorSatAdd(GrColor c0, GrColor c1) {
116 unsigned r = SkTMin<unsigned>(GrColorUnpackR(c0) + GrColorUnpackR(c1), 0xff);
117 unsigned g = SkTMin<unsigned>(GrColorUnpackG(c0) + GrColorUnpackG(c1), 0xff);
118 unsigned b = SkTMin<unsigned>(GrColorUnpackB(c0) + GrColorUnpackB(c1), 0xff);
119 unsigned a = SkTMin<unsigned>(GrColorUnpackA(c0) + GrColorUnpackA(c1), 0xff);
120 return GrColorPackRGBA(r, g, b, a);
124 static inline void GrColorToRGBAFloat(GrColor color,
float rgba[4]) {
125 static const float ONE_OVER_255 = 1.f / 255.f;
126 rgba[0] = GrColorUnpackR(color) * ONE_OVER_255;
127 rgba[1] = GrColorUnpackG(color) * ONE_OVER_255;
128 rgba[2] = GrColorUnpackB(color) * ONE_OVER_255;
129 rgba[3] = GrColorUnpackA(color) * ONE_OVER_255;
133 static inline float GrNormalizeByteToFloat(uint8_t value) {
134 static const float ONE_OVER_255 = 1.f / 255.f;
135 return value * ONE_OVER_255;
139 static inline bool GrColorIsOpaque(GrColor color) {
140 return (color & (0xFFU << GrColor_SHIFT_A)) == (0xFFU << GrColor_SHIFT_A);
143 static inline GrColor GrPremulColor(GrColor color) {
144 unsigned r = GrColorUnpackR(color);
145 unsigned g = GrColorUnpackG(color);
146 unsigned b = GrColorUnpackB(color);
147 unsigned a = GrColorUnpackA(color);
148 return GrColorPackRGBA(SkMulDiv255Round(r, a),
149 SkMulDiv255Round(g, a),
150 SkMulDiv255Round(b, a),
155 static inline GrColor GrUnpremulColor(GrColor color) {
156 GrColorIsPMAssert(color);
157 unsigned r = GrColorUnpackR(color);
158 unsigned g = GrColorUnpackG(color);
159 unsigned b = GrColorUnpackB(color);
160 unsigned a = GrColorUnpackA(color);
161 SkPMColor colorPM = SkPackARGB32(a, r, g, b);
162 SkColor colorUPM = SkUnPreMultiply::PMColorToColor(colorPM);
169 return GrColorPackRGBA(r, g, b, a);
181 GrColor4f(
float r,
float g,
float b,
float a) {
188 static GrColor4f FromGrColor(GrColor color) {
190 GrColorToRGBAFloat(color, result.fRGBA);
195 return GrColor4f(color.fR, color.fG, color.fB, color.fA);
198 GrColor toGrColor()
const {
199 return GrColorPackRGBA(
200 SkTPin<unsigned>(static_cast<unsigned>(fRGBA[0] * 255.0f + 0.5f), 0, 255),
201 SkTPin<unsigned>(static_cast<unsigned>(fRGBA[1] * 255.0f + 0.5f), 0, 255),
202 SkTPin<unsigned>(static_cast<unsigned>(fRGBA[2] * 255.0f + 0.5f), 0, 255),
203 SkTPin<unsigned>(static_cast<unsigned>(fRGBA[3] * 255.0f + 0.5f), 0, 255));
207 return SkColor4f { fRGBA[0], fRGBA[1], fRGBA[2], fRGBA[3] };
211 return GrColor4f(fRGBA[0], fRGBA[1], fRGBA[2], 1.0f);
216 return GrColor4f(fRGBA[0] * a, fRGBA[1] * a, fRGBA[2] * a, a);
224 enum GrColorComponentFlags {
225 kR_GrColorComponentFlag = 1 << (GrColor_SHIFT_R / 8),
226 kG_GrColorComponentFlag = 1 << (GrColor_SHIFT_G / 8),
227 kB_GrColorComponentFlag = 1 << (GrColor_SHIFT_B / 8),
228 kA_GrColorComponentFlag = 1 << (GrColor_SHIFT_A / 8),
230 kNone_GrColorComponentFlags = 0,
232 kRGB_GrColorComponentFlags = (kR_GrColorComponentFlag | kG_GrColorComponentFlag |
233 kB_GrColorComponentFlag),
235 kRGBA_GrColorComponentFlags = (kR_GrColorComponentFlag | kG_GrColorComponentFlag |
236 kB_GrColorComponentFlag | kA_GrColorComponentFlag)
239 GR_MAKE_BITFIELD_OPS(GrColorComponentFlags)
241 static inline
char GrColorComponentFlagToChar(GrColorComponentFlags component) {
242 SkASSERT(SkIsPow2(component));
244 case kR_GrColorComponentFlag:
246 case kG_GrColorComponentFlag:
248 case kB_GrColorComponentFlag:
250 case kA_GrColorComponentFlag:
253 SkFAIL(
"Invalid color component flag.");
258 static inline uint32_t GrPixelConfigComponentMask(GrPixelConfig config) {
259 static const uint32_t kFlags[] = {
261 kA_GrColorComponentFlag,
262 kRGBA_GrColorComponentFlags,
263 kRGB_GrColorComponentFlags,
264 kRGBA_GrColorComponentFlags,
265 kRGBA_GrColorComponentFlags,
266 kRGBA_GrColorComponentFlags,
267 kRGBA_GrColorComponentFlags,
268 kRGBA_GrColorComponentFlags,
269 kRGB_GrColorComponentFlags,
270 kA_GrColorComponentFlag,
271 kA_GrColorComponentFlag,
272 kRGBA_GrColorComponentFlags,
273 kRGBA_GrColorComponentFlags,
274 kA_GrColorComponentFlag,
275 kRGBA_GrColorComponentFlags,
277 return kFlags[config];
279 GR_STATIC_ASSERT(0 == kUnknown_GrPixelConfig);
280 GR_STATIC_ASSERT(1 == kAlpha_8_GrPixelConfig);
281 GR_STATIC_ASSERT(2 == kIndex_8_GrPixelConfig);
282 GR_STATIC_ASSERT(3 == kRGB_565_GrPixelConfig);
283 GR_STATIC_ASSERT(4 == kRGBA_4444_GrPixelConfig);
284 GR_STATIC_ASSERT(5 == kRGBA_8888_GrPixelConfig);
285 GR_STATIC_ASSERT(6 == kBGRA_8888_GrPixelConfig);
286 GR_STATIC_ASSERT(7 == kSRGBA_8888_GrPixelConfig);
287 GR_STATIC_ASSERT(8 == kSBGRA_8888_GrPixelConfig);
288 GR_STATIC_ASSERT(9 == kETC1_GrPixelConfig);
289 GR_STATIC_ASSERT(10 == kLATC_GrPixelConfig);
290 GR_STATIC_ASSERT(11 == kR11_EAC_GrPixelConfig);
291 GR_STATIC_ASSERT(12 == kASTC_12x12_GrPixelConfig);
292 GR_STATIC_ASSERT(13 == kRGBA_float_GrPixelConfig);
293 GR_STATIC_ASSERT(14 == kAlpha_half_GrPixelConfig);
294 GR_STATIC_ASSERT(15 == kRGBA_half_GrPixelConfig);
295 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kFlags) == kGrPixelConfigCnt);
Definition: SkColor.h:169
#define SkColorGetG(color)
return the green byte from a SkColor value
Definition: SkColor.h:66
Similarly, GrColor4f is 4 floats for R, G, B, A, in that order.
Definition: GrColor.h:177
uint32_t SkPMColor
32 bit ARGB color value, premultiplied.
Definition: SkColor.h:147
uint32_t SkColor
32 bit ARGB color value, not premultiplied.
Definition: SkColor.h:28
#define SkColorGetB(color)
return the blue byte from a SkColor value
Definition: SkColor.h:68
#define SkColorGetR(color)
return the red byte from a SkColor value
Definition: SkColor.h:64
#define SkColorGetA(color)
return the alpha byte from a SkColor value
Definition: SkColor.h:62
unsigned U8CPU
Fast type for unsigned 8 bits.
Definition: SkTypes.h:251
Types and macros for colors.