c0bd9f9fe5
Current strategy: everything from the top
Things to look at first are the manual changes:
- added tools/rewrite_includes.py
- removed -Idirectives from BUILD.gn
- various compile.sh simplifications
- tweak tools/embed_resources.py
- update gn/find_headers.py to write paths from the top
- update gn/gn_to_bp.py SkUserConfig.h layout
so that #include "include/config/SkUserConfig.h" always
gets the header we want.
No-Presubmit: true
Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Hal Canary <halcanary@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
113 lines
3.5 KiB
C++
113 lines
3.5 KiB
C++
|
|
/*
|
|
* Copyright 2010 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
|
|
|
|
#ifndef GrColor_DEFINED
|
|
#define GrColor_DEFINED
|
|
|
|
#include "include/core/SkColor.h"
|
|
#include "include/core/SkColorPriv.h"
|
|
#include "include/private/SkColorData.h"
|
|
#include "include/private/SkHalf.h"
|
|
|
|
/**
|
|
* GrColor is 4 bytes for R, G, B, A, in a specific order defined below. Whether the color is
|
|
* premultiplied or not depends on the context in which it is being used.
|
|
*/
|
|
typedef uint32_t GrColor;
|
|
|
|
// shift amount to assign a component to a GrColor int
|
|
// These shift values are chosen for compatibility with GL attrib arrays
|
|
// ES doesn't allow BGRA vertex attrib order so if they were not in this order
|
|
// we'd have to swizzle in shaders.
|
|
#ifdef SK_CPU_BENDIAN
|
|
#define GrColor_SHIFT_R 24
|
|
#define GrColor_SHIFT_G 16
|
|
#define GrColor_SHIFT_B 8
|
|
#define GrColor_SHIFT_A 0
|
|
#else
|
|
#define GrColor_SHIFT_R 0
|
|
#define GrColor_SHIFT_G 8
|
|
#define GrColor_SHIFT_B 16
|
|
#define GrColor_SHIFT_A 24
|
|
#endif
|
|
|
|
/**
|
|
* Pack 4 components (RGBA) into a GrColor int
|
|
*/
|
|
static inline GrColor GrColorPackRGBA(unsigned r, unsigned g, unsigned b, unsigned a) {
|
|
SkASSERT((uint8_t)r == r);
|
|
SkASSERT((uint8_t)g == g);
|
|
SkASSERT((uint8_t)b == b);
|
|
SkASSERT((uint8_t)a == a);
|
|
return (r << GrColor_SHIFT_R) |
|
|
(g << GrColor_SHIFT_G) |
|
|
(b << GrColor_SHIFT_B) |
|
|
(a << GrColor_SHIFT_A);
|
|
}
|
|
|
|
// extract a component (byte) from a GrColor int
|
|
|
|
#define GrColorUnpackR(color) (((color) >> GrColor_SHIFT_R) & 0xFF)
|
|
#define GrColorUnpackG(color) (((color) >> GrColor_SHIFT_G) & 0xFF)
|
|
#define GrColorUnpackB(color) (((color) >> GrColor_SHIFT_B) & 0xFF)
|
|
#define GrColorUnpackA(color) (((color) >> GrColor_SHIFT_A) & 0xFF)
|
|
|
|
/**
|
|
* Since premultiplied means that alpha >= color, we construct a color with
|
|
* each component==255 and alpha == 0 to be "illegal"
|
|
*/
|
|
#define GrColor_ILLEGAL (~(0xFF << GrColor_SHIFT_A))
|
|
|
|
/** Normalizes and coverts an uint8_t to a float. [0, 255] -> [0.0, 1.0] */
|
|
static inline float GrNormalizeByteToFloat(uint8_t value) {
|
|
static const float ONE_OVER_255 = 1.f / 255.f;
|
|
return value * ONE_OVER_255;
|
|
}
|
|
|
|
/** Used to pick vertex attribute types. */
|
|
static inline bool SkPMColor4fFitsInBytes(const SkPMColor4f& color) {
|
|
// Might want to instead check that the components are [0...a] instead of [0...1]?
|
|
return color.fitsInBytes();
|
|
}
|
|
|
|
static inline uint64_t SkPMColor4f_toFP16(const SkPMColor4f& color) {
|
|
uint64_t halfColor;
|
|
SkFloatToHalf_finite_ftz(Sk4f::Load(color.vec())).store(&halfColor);
|
|
return halfColor;
|
|
}
|
|
|
|
/**
|
|
* GrVertexColor is a helper for writing colors to a vertex attribute. It stores either GrColor
|
|
* or four half-float channels, depending on the wideColor parameter. GrVertexWriter will write
|
|
* the correct amount of data. Note that the GP needs to have been constructed with the correct
|
|
* attribute type for colors, to match the usage here.
|
|
*/
|
|
class GrVertexColor {
|
|
public:
|
|
explicit GrVertexColor(const SkPMColor4f& color, bool wideColor)
|
|
: fWideColor(wideColor) {
|
|
if (wideColor) {
|
|
SkFloatToHalf_finite_ftz(Sk4f::Load(color.vec())).store(&fColor);
|
|
} else {
|
|
fColor[0] = color.toBytes_RGBA();
|
|
}
|
|
}
|
|
|
|
size_t size() const { return fWideColor ? 8 : 4; }
|
|
|
|
private:
|
|
friend struct GrVertexWriter;
|
|
|
|
uint32_t fColor[2];
|
|
bool fWideColor;
|
|
};
|
|
|
|
#endif
|