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 "include/core/SkColor.h"
15 #include "include/core/SkColorPriv.h"
16 #include "include/gpu/GrTypes.h"
17 #include "include/private/SkColorData.h"
18 #include "include/private/SkHalf.h"
19 #include "src/gpu/BufferWriter.h"
20
21 /**
22 * GrColor is 4 bytes for R, G, B, A, in a specific order defined below. Whether the color is
23 * premultiplied or not depends on the context in which it is being used.
24 */
25 typedef uint32_t GrColor;
26
27 // shift amount to assign a component to a GrColor int
28 // These shift values are chosen for compatibility with GL attrib arrays
29 // ES doesn't allow BGRA vertex attrib order so if they were not in this order
30 // we'd have to swizzle in shaders.
31 #ifdef SK_CPU_BENDIAN
32 #define GrColor_SHIFT_R 24
33 #define GrColor_SHIFT_G 16
34 #define GrColor_SHIFT_B 8
35 #define GrColor_SHIFT_A 0
36 #else
37 #define GrColor_SHIFT_R 0
38 #define GrColor_SHIFT_G 8
39 #define GrColor_SHIFT_B 16
40 #define GrColor_SHIFT_A 24
41 #endif
42
43 /**
44 * Pack 4 components (RGBA) into a GrColor int
45 */
GrColorPackRGBA(unsigned r,unsigned g,unsigned b,unsigned a)46 static inline GrColor GrColorPackRGBA(unsigned r, unsigned g, unsigned b, unsigned a) {
47 SkASSERT((uint8_t)r == r);
48 SkASSERT((uint8_t)g == g);
49 SkASSERT((uint8_t)b == b);
50 SkASSERT((uint8_t)a == a);
51 return (r << GrColor_SHIFT_R) |
52 (g << GrColor_SHIFT_G) |
53 (b << GrColor_SHIFT_B) |
54 (a << GrColor_SHIFT_A);
55 }
56
57 // extract a component (byte) from a GrColor int
58
59 #define GrColorUnpackR(color) (((color) >> GrColor_SHIFT_R) & 0xFF)
60 #define GrColorUnpackG(color) (((color) >> GrColor_SHIFT_G) & 0xFF)
61 #define GrColorUnpackB(color) (((color) >> GrColor_SHIFT_B) & 0xFF)
62 #define GrColorUnpackA(color) (((color) >> GrColor_SHIFT_A) & 0xFF)
63
64 /**
65 * Since premultiplied means that alpha >= color, we construct a color with
66 * each component==255 and alpha == 0 to be "illegal"
67 */
68 #define GrColor_ILLEGAL (~(0xFF << GrColor_SHIFT_A))
69
70 /** Normalizes and coverts an uint8_t to a float. [0, 255] -> [0.0, 1.0] */
GrNormalizeByteToFloat(uint8_t value)71 static inline float GrNormalizeByteToFloat(uint8_t value) {
72 static const float ONE_OVER_255 = 1.f / 255.f;
73 return value * ONE_OVER_255;
74 }
75
76 /** Used to pick vertex attribute types. */
SkPMColor4fFitsInBytes(const SkPMColor4f & color)77 static inline bool SkPMColor4fFitsInBytes(const SkPMColor4f& color) {
78 // Might want to instead check that the components are [0...a] instead of [0...1]?
79 return color.fitsInBytes();
80 }
81
SkPMColor4f_toFP16(const SkPMColor4f & color)82 static inline uint64_t SkPMColor4f_toFP16(const SkPMColor4f& color) {
83 uint64_t halfColor;
84 SkFloatToHalf_finite_ftz(Sk4f::Load(color.vec())).store(&halfColor);
85 return halfColor;
86 }
87
88 /**
89 * GrVertexColor is a helper for writing colors to a vertex attribute. It stores either GrColor
90 * or four half-float channels, depending on the wideColor parameter. VertexWriter will write the
91 * correct amount of data. Note that the GP needs to have been constructed with the correct
92 * attribute type for colors, to match the usage here.
93 */
94 class GrVertexColor {
95 public:
96 GrVertexColor() = default;
97
GrVertexColor(const SkPMColor4f & color,bool wideColor)98 explicit GrVertexColor(const SkPMColor4f& color, bool wideColor) {
99 this->set(color, wideColor);
100 }
101
set(const SkPMColor4f & color,bool wideColor)102 void set(const SkPMColor4f& color, bool wideColor) {
103 if (wideColor) {
104 memcpy(fColor, color.vec(), sizeof(fColor));
105 } else {
106 fColor[0] = color.toBytes_RGBA();
107 }
108 fWideColor = wideColor;
109 }
110
size()111 size_t size() const { return fWideColor ? 16 : 4; }
112
113 private:
114 template <typename T>
115 friend skgpu::VertexWriter& skgpu::operator<<(skgpu::VertexWriter&, const T&);
116
117 uint32_t fColor[4];
118 bool fWideColor;
119 };
120
121 template <>
122 SK_MAYBE_UNUSED inline skgpu::VertexWriter& skgpu::operator<<(skgpu::VertexWriter& w,
123 const GrVertexColor& color) {
124 w << color.fColor[0];
125 if (color.fWideColor) {
126 w << color.fColor[1]
127 << color.fColor[2]
128 << color.fColor[3];
129 }
130 return w;
131 }
132
133 #endif
134