epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 2 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 3 | * Copyright 2010 Google Inc. |
| 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 10 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 11 | #ifndef GrColor_DEFINED |
| 12 | #define GrColor_DEFINED |
| 13 | |
| 14 | #include "GrTypes.h" |
egdaniel | 4bd4e80 | 2014-12-01 12:30:50 -0800 | [diff] [blame] | 15 | #include "SkColor.h" |
| 16 | #include "SkColorPriv.h" |
| 17 | #include "SkUnPreMultiply.h" |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 18 | |
| 19 | /** |
bsalomon | f1b7a1d | 2015-09-28 06:26:28 -0700 | [diff] [blame] | 20 | * GrColor is 4 bytes for R, G, B, A, in a specific order defined below. Whether the color is |
| 21 | * premultiplied or not depends on the context in which it is being used. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 22 | */ |
| 23 | typedef uint32_t GrColor; |
| 24 | |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 25 | // shift amount to assign a component to a GrColor int |
| 26 | // These shift values are chosen for compatibility with GL attrib arrays |
| 27 | // ES doesn't allow BGRA vertex attrib order so if they were not in this order |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 28 | // we'd have to swizzle in shaders. |
| 29 | #ifdef SK_CPU_BENDIAN |
| 30 | #define GrColor_SHIFT_R 24 |
| 31 | #define GrColor_SHIFT_G 16 |
| 32 | #define GrColor_SHIFT_B 8 |
| 33 | #define GrColor_SHIFT_A 0 |
| 34 | #else |
| 35 | #define GrColor_SHIFT_R 0 |
| 36 | #define GrColor_SHIFT_G 8 |
| 37 | #define GrColor_SHIFT_B 16 |
| 38 | #define GrColor_SHIFT_A 24 |
| 39 | #endif |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 40 | |
| 41 | /** |
| 42 | * Pack 4 components (RGBA) into a GrColor int |
| 43 | */ |
bsalomon | b0ae649 | 2014-12-29 07:05:27 -0800 | [diff] [blame] | 44 | static inline GrColor GrColorPackRGBA(unsigned r, unsigned g, unsigned b, unsigned a) { |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 45 | SkASSERT((uint8_t)r == r); |
| 46 | SkASSERT((uint8_t)g == g); |
| 47 | SkASSERT((uint8_t)b == b); |
| 48 | SkASSERT((uint8_t)a == a); |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 49 | return (r << GrColor_SHIFT_R) | |
| 50 | (g << GrColor_SHIFT_G) | |
| 51 | (b << GrColor_SHIFT_B) | |
| 52 | (a << GrColor_SHIFT_A); |
| 53 | } |
| 54 | |
bsalomon | b0ae649 | 2014-12-29 07:05:27 -0800 | [diff] [blame] | 55 | /** |
| 56 | * Packs a color with an alpha channel replicated across all four channels. |
| 57 | */ |
| 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); |
| 64 | } |
| 65 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 66 | // extract a component (byte) from a GrColor int |
| 67 | |
| 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) |
| 72 | |
| 73 | /** |
| 74 | * Since premultiplied means that alpha >= color, we construct a color with |
| 75 | * each component==255 and alpha == 0 to be "illegal" |
| 76 | */ |
| 77 | #define GrColor_ILLEGAL (~(0xFF << GrColor_SHIFT_A)) |
| 78 | |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 79 | #define GrColor_WHITE 0xFFFFFFFF |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 80 | #define GrColor_TRANSPARENT_BLACK 0x0 |
joshualitt | 2e3b3e3 | 2014-12-09 13:31:14 -0800 | [diff] [blame] | 81 | |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 82 | /** |
| 83 | * Assert in debug builds that a GrColor is premultiplied. |
| 84 | */ |
djsollen | c87dd2c | 2014-11-14 11:11:46 -0800 | [diff] [blame] | 85 | static inline void GrColorIsPMAssert(GrColor SkDEBUGCODE(c)) { |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 86 | #ifdef SK_DEBUG |
| 87 | unsigned a = GrColorUnpackA(c); |
| 88 | unsigned r = GrColorUnpackR(c); |
| 89 | unsigned g = GrColorUnpackG(c); |
| 90 | unsigned b = GrColorUnpackB(c); |
| 91 | |
| 92 | SkASSERT(r <= a); |
| 93 | SkASSERT(g <= a); |
| 94 | SkASSERT(b <= a); |
| 95 | #endif |
| 96 | } |
| 97 | |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 98 | /** Inverts each color channel. */ |
| 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); |
| 105 | } |
| 106 | |
| 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); |
| 113 | } |
| 114 | |
| 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); |
| 121 | } |
| 122 | |
bsalomon@google.com | 7534747 | 2012-09-17 17:23:21 +0000 | [diff] [blame] | 123 | /** Converts a GrColor to an rgba array of GrGLfloat */ |
| 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; |
| 130 | } |
| 131 | |
egdaniel | e27065a | 2014-11-06 08:00:48 -0800 | [diff] [blame] | 132 | /** Normalizes and coverts an uint8_t to a float. [0, 255] -> [0.0, 1.0] */ |
| 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; |
| 136 | } |
| 137 | |
bsalomon | 9c0822a | 2014-08-11 11:07:48 -0700 | [diff] [blame] | 138 | /** Determines whether the color is opaque or not. */ |
| 139 | static inline bool GrColorIsOpaque(GrColor color) { |
| 140 | return (color & (0xFFU << GrColor_SHIFT_A)) == (0xFFU << GrColor_SHIFT_A); |
| 141 | } |
| 142 | |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 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), |
| 151 | a); |
| 152 | } |
| 153 | |
egdaniel | 4bd4e80 | 2014-12-01 12:30:50 -0800 | [diff] [blame] | 154 | /** Returns an unpremuled version of the GrColor. */ |
bsalomon | ae4738f | 2015-09-15 15:33:27 -0700 | [diff] [blame] | 155 | static inline GrColor GrUnpremulColor(GrColor color) { |
| 156 | GrColorIsPMAssert(color); |
egdaniel | 4bd4e80 | 2014-12-01 12:30:50 -0800 | [diff] [blame] | 157 | unsigned r = GrColorUnpackR(color); |
Ben Wagner | 63fd760 | 2017-10-09 15:45:33 -0400 | [diff] [blame] | 158 | unsigned g = GrColorUnpackG(color); |
egdaniel | 4bd4e80 | 2014-12-01 12:30:50 -0800 | [diff] [blame] | 159 | unsigned b = GrColorUnpackB(color); |
| 160 | unsigned a = GrColorUnpackA(color); |
| 161 | SkPMColor colorPM = SkPackARGB32(a, r, g, b); |
| 162 | SkColor colorUPM = SkUnPreMultiply::PMColorToColor(colorPM); |
| 163 | |
egdaniel | 4ccf0b9 | 2014-12-08 12:35:16 -0800 | [diff] [blame] | 164 | r = SkColorGetR(colorUPM); |
| 165 | g = SkColorGetG(colorUPM); |
| 166 | b = SkColorGetB(colorUPM); |
| 167 | a = SkColorGetA(colorUPM); |
egdaniel | 4bd4e80 | 2014-12-01 12:30:50 -0800 | [diff] [blame] | 168 | |
| 169 | return GrColorPackRGBA(r, g, b, a); |
| 170 | } |
| 171 | |
brianosman | a4535a3 | 2016-06-24 12:50:19 -0700 | [diff] [blame] | 172 | |
| 173 | /** |
| 174 | * Similarly, GrColor4f is 4 floats for R, G, B, A, in that order. And like GrColor, whether |
| 175 | * the color is premultiplied or not depends on the context. |
| 176 | */ |
| 177 | struct GrColor4f { |
| 178 | float fRGBA[4]; |
| 179 | |
| 180 | GrColor4f() {} |
| 181 | GrColor4f(float r, float g, float b, float a) { |
| 182 | fRGBA[0] = r; |
| 183 | fRGBA[1] = g; |
| 184 | fRGBA[2] = b; |
| 185 | fRGBA[3] = a; |
| 186 | } |
| 187 | |
Brian Osman | 618d304 | 2016-10-25 10:51:28 -0400 | [diff] [blame] | 188 | enum Illegal_Constructor { |
| 189 | kIllegalConstructor |
| 190 | }; |
| 191 | GrColor4f(Illegal_Constructor) { |
| 192 | fRGBA[0] = SK_FloatNaN; |
| 193 | fRGBA[1] = SK_FloatNaN; |
| 194 | fRGBA[2] = SK_FloatNaN; |
| 195 | fRGBA[3] = SK_FloatNaN; |
| 196 | } |
| 197 | |
| 198 | static GrColor4f OpaqueWhite() { |
| 199 | return GrColor4f(1.0f, 1.0f, 1.0f, 1.0f); |
| 200 | } |
| 201 | |
| 202 | static GrColor4f TransparentBlack() { |
| 203 | return GrColor4f(0.0f, 0.0f, 0.0f, 0.0f); |
| 204 | } |
| 205 | |
brianosman | a4535a3 | 2016-06-24 12:50:19 -0700 | [diff] [blame] | 206 | static GrColor4f FromGrColor(GrColor color) { |
| 207 | GrColor4f result; |
| 208 | GrColorToRGBAFloat(color, result.fRGBA); |
| 209 | return result; |
| 210 | } |
| 211 | |
| 212 | static GrColor4f FromSkColor4f(const SkColor4f& color) { |
| 213 | return GrColor4f(color.fR, color.fG, color.fB, color.fA); |
| 214 | } |
| 215 | |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 216 | GrColor4f modulate(const GrColor4f& x) const { |
| 217 | return GrColor4f(fRGBA[0] * x.fRGBA[0], |
| 218 | fRGBA[1] * x.fRGBA[1], |
| 219 | fRGBA[2] * x.fRGBA[2], |
| 220 | fRGBA[3] * x.fRGBA[3]); |
| 221 | } |
| 222 | |
| 223 | GrColor4f mulByScalar(float x) const { |
| 224 | return GrColor4f(fRGBA[0] * x, fRGBA[1] * x, fRGBA[2] * x, fRGBA[3] * x); |
| 225 | } |
| 226 | |
brianosman | 4cea3b9 | 2016-09-08 09:33:50 -0700 | [diff] [blame] | 227 | bool operator==(const GrColor4f& other) const { |
| 228 | return |
| 229 | fRGBA[0] == other.fRGBA[0] && |
| 230 | fRGBA[1] == other.fRGBA[1] && |
| 231 | fRGBA[2] == other.fRGBA[2] && |
| 232 | fRGBA[3] == other.fRGBA[3]; |
| 233 | } |
| 234 | bool operator!=(const GrColor4f& other) const { |
| 235 | return !(*this == other); |
| 236 | } |
| 237 | |
brianosman | a4535a3 | 2016-06-24 12:50:19 -0700 | [diff] [blame] | 238 | GrColor toGrColor() const { |
| 239 | return GrColorPackRGBA( |
| 240 | SkTPin<unsigned>(static_cast<unsigned>(fRGBA[0] * 255.0f + 0.5f), 0, 255), |
| 241 | SkTPin<unsigned>(static_cast<unsigned>(fRGBA[1] * 255.0f + 0.5f), 0, 255), |
| 242 | SkTPin<unsigned>(static_cast<unsigned>(fRGBA[2] * 255.0f + 0.5f), 0, 255), |
| 243 | SkTPin<unsigned>(static_cast<unsigned>(fRGBA[3] * 255.0f + 0.5f), 0, 255)); |
| 244 | } |
| 245 | |
| 246 | SkColor4f toSkColor4f() const { |
| 247 | return SkColor4f { fRGBA[0], fRGBA[1], fRGBA[2], fRGBA[3] }; |
| 248 | } |
| 249 | |
| 250 | GrColor4f opaque() const { |
| 251 | return GrColor4f(fRGBA[0], fRGBA[1], fRGBA[2], 1.0f); |
| 252 | } |
| 253 | |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 254 | bool isOpaque() const { |
| 255 | return fRGBA[3] >= 1.f; // just in case precision causes a superopaque value. |
| 256 | } |
| 257 | |
brianosman | a4535a3 | 2016-06-24 12:50:19 -0700 | [diff] [blame] | 258 | GrColor4f premul() const { |
| 259 | float a = fRGBA[3]; |
| 260 | return GrColor4f(fRGBA[0] * a, fRGBA[1] * a, fRGBA[2] * a, a); |
| 261 | } |
Brian Osman | de1a605 | 2017-03-22 10:57:00 -0400 | [diff] [blame] | 262 | |
| 263 | GrColor4f unpremul() const { |
| 264 | float a = fRGBA[3]; |
| 265 | if (a <= 0.0f) { |
| 266 | return GrColor4f(0.0f, 0.0f, 0.0f, 0.0f); |
| 267 | } |
| 268 | float invAlpha = 1.0f / a; |
| 269 | return GrColor4f(fRGBA[0] * invAlpha, fRGBA[1] * invAlpha, fRGBA[2] * invAlpha, a); |
| 270 | } |
brianosman | a4535a3 | 2016-06-24 12:50:19 -0700 | [diff] [blame] | 271 | }; |
| 272 | |
bsalomon@google.com | b8eb2e8 | 2013-03-28 13:46:42 +0000 | [diff] [blame] | 273 | /** |
| 274 | * Flags used for bitfields of color components. They are defined so that the bit order reflects the |
| 275 | * GrColor shift order. |
| 276 | */ |
| 277 | enum GrColorComponentFlags { |
| 278 | kR_GrColorComponentFlag = 1 << (GrColor_SHIFT_R / 8), |
| 279 | kG_GrColorComponentFlag = 1 << (GrColor_SHIFT_G / 8), |
| 280 | kB_GrColorComponentFlag = 1 << (GrColor_SHIFT_B / 8), |
| 281 | kA_GrColorComponentFlag = 1 << (GrColor_SHIFT_A / 8), |
| 282 | |
cdalton | 6fd158e | 2015-05-27 15:08:33 -0700 | [diff] [blame] | 283 | kNone_GrColorComponentFlags = 0, |
| 284 | |
bsalomon@google.com | b8eb2e8 | 2013-03-28 13:46:42 +0000 | [diff] [blame] | 285 | kRGB_GrColorComponentFlags = (kR_GrColorComponentFlag | kG_GrColorComponentFlag | |
| 286 | kB_GrColorComponentFlag), |
| 287 | |
| 288 | kRGBA_GrColorComponentFlags = (kR_GrColorComponentFlag | kG_GrColorComponentFlag | |
| 289 | kB_GrColorComponentFlag | kA_GrColorComponentFlag) |
| 290 | }; |
| 291 | |
cdalton | 6fd158e | 2015-05-27 15:08:33 -0700 | [diff] [blame] | 292 | GR_MAKE_BITFIELD_OPS(GrColorComponentFlags) |
| 293 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 294 | #endif |