Home | History | Annotate | Download | only in private 
      1 
      2 /*
      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.
      7  */
      8 
      9 
     10 
     11 #ifndef GrColor_DEFINED
     12 #define GrColor_DEFINED
     13 
     14 #include "GrTypes.h"
     15 #include "SkColor.h"
     16 #include "SkColorPriv.h"
     17 #include "SkUnPreMultiply.h"
     18 
     19 /**
     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.
     22  */
     23 typedef uint32_t GrColor;
     24 
     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
     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
     40 
     41 /**
     42  *  Pack 4 components (RGBA) into a GrColor int
     43  */
     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);
     53 }
     54 
     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 
     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 
     79 #define GrColor_WHITE 0xFFFFFFFF
     80 #define GrColor_TRANSPARENT_BLACK 0x0
     81 
     82 /**
     83  * Assert in debug builds that a GrColor is premultiplied.
     84  */
     85 static inline void GrColorIsPMAssert(GrColor SkDEBUGCODE(c)) {
     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 
     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 
    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 
    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 
    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 
    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 
    154 /** Returns an unpremuled version of the GrColor. */
    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);
    163 
    164     r = SkColorGetR(colorUPM);
    165     g = SkColorGetG(colorUPM);
    166     b = SkColorGetB(colorUPM);
    167     a = SkColorGetA(colorUPM);
    168 
    169     return GrColorPackRGBA(r, g, b, a);
    170 }
    171 
    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 
    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 
    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 
    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 
    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 
    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 
    254     bool isOpaque() const {
    255         return fRGBA[3] >= 1.f;  // just in case precision causes a superopaque value.
    256     }
    257 
    258     GrColor4f premul() const {
    259         float a = fRGBA[3];
    260         return GrColor4f(fRGBA[0] * a, fRGBA[1] * a, fRGBA[2] * a, a);
    261     }
    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     }
    271 };
    272 
    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 
    283     kNone_GrColorComponentFlags = 0,
    284 
    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 
    292 GR_MAKE_BITFIELD_OPS(GrColorComponentFlags)
    293 
    294 #endif
    295