4d75975b70
Docs-Preview: https://skia.org/?cl=135785 Bug: skia:6898 Change-Id: Idf5e44817a86accaa628ea5d7abb47cd2b06d048 Reviewed-on: https://skia-review.googlesource.com/135785 Commit-Queue: Cary Clark <caryclark@skia.org> Auto-Submit: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
864 lines
26 KiB
Plaintext
864 lines
26 KiB
Plaintext
#Topic Color
|
|
#Alias Color_Reference ##
|
|
|
|
#File
|
|
Types, consts, functions, and macros for colors.
|
|
##
|
|
|
|
#Subtopic Overview
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Define
|
|
#Populate
|
|
##
|
|
|
|
Color constants can be helpful to write code, documenting the meaning of values
|
|
the represent transparency and color values. The use of Color constants is not
|
|
required.
|
|
|
|
#Subtopic Constant
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Function
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Typedef
|
|
#Populate
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Alpha
|
|
|
|
Alpha represents the transparency of Color. Color with Alpha of zero is fully
|
|
transparent. Color with Alpha of 255 is fully opaque. Some, but not all pixel
|
|
formats contain Alpha. Pixels with Alpha may store it as unsigned integers or
|
|
floating point values. Unsigned integer Alpha ranges from zero, fully
|
|
transparent, to all bits set, fully opaque. Floating point Alpha ranges from
|
|
zero, fully transparent, to one, fully opaque.
|
|
|
|
#Alias Alpha
|
|
#Substitute alpha
|
|
##
|
|
|
|
#Typedef uint8_t SkAlpha
|
|
#Line # defines Alpha as eight bits ##
|
|
|
|
#Code
|
|
typedef uint8_t SkAlpha;
|
|
##
|
|
|
|
8-bit type for an alpha value. 255 is 100% opaque, zero is 100% transparent.
|
|
|
|
#Typedef ##
|
|
|
|
#Subtopic ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Typedef uint32_t SkColor
|
|
#Line # defines Color as 32 bits ##
|
|
|
|
#Code
|
|
typedef uint32_t SkColor;
|
|
##
|
|
|
|
32-bit ARGB Color value, Unpremultiplied. Color components are always in
|
|
a known order. This is different from SkPMColor, which has its bytes in a configuration
|
|
dependent order, to match the format of kBGRA_8888_SkColorType bitmaps. SkColor
|
|
is the type used to specify colors in SkPaint and in gradients.
|
|
|
|
Color that is Premultiplied has the same component values as Color
|
|
that is Unpremultiplied if Alpha is 255, fully opaque, although may have the
|
|
component values in a different order.
|
|
|
|
#SeeAlso SkPMColor
|
|
|
|
#Typedef ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static constexpr inline SkColor SkColorSetARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
|
|
#In Function
|
|
#Line # returns Color_Alpha and RGB combined ##
|
|
|
|
Returns Color value from 8-bit component values. Asserts if SK_DEBUG is defined
|
|
if a, r, g, or b exceed 255. Since Color is Unpremultiplied, a may be smaller
|
|
than the largest of r, g, and b.
|
|
|
|
#Param a amount of Alpha, from fully transparent (0) to fully opaque (255) ##
|
|
#Param r amount of red, from no red (0) to full red (255) ##
|
|
#Param g amount of green, from no green (0) to full green (255) ##
|
|
#Param b amount of blue, from no blue (0) to full blue (255) ##
|
|
|
|
#Return color and alpha, Unpremultiplied ##
|
|
|
|
#Example
|
|
canvas->drawColor(SK_ColorRED);
|
|
canvas->clipRect(SkRect::MakeWH(150, 150));
|
|
canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0xFF, 0x00));
|
|
canvas->clipRect(SkRect::MakeWH(75, 75));
|
|
canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0x00, 0xFF));
|
|
##
|
|
|
|
#SeeAlso SkColorSetRGB SkPaint::setARGB SkPaint::setColor SkColorSetA
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Define SkColorSetRGB
|
|
#Line # returns opaque Color ##
|
|
|
|
#Code
|
|
###$
|
|
#define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b)
|
|
$$$#
|
|
##
|
|
|
|
Returns Color value from 8-bit component values, with Alpha set
|
|
fully opaque to 255.
|
|
|
|
#Param r amount of red, from no red (0) to full red (255) ##
|
|
#Param g amount of green, from no green (0) to full green (255) ##
|
|
#Param b amount of blue, from no blue (0) to full blue (255) ##
|
|
|
|
#Return color with opaque alpha ##
|
|
|
|
#Example
|
|
canvas->drawColor(SK_ColorRED);
|
|
canvas->clipRect(SkRect::MakeWH(150, 150));
|
|
canvas->drawColor(SkColorSetRGB(0x00, 0xFF, 0x00));
|
|
canvas->clipRect(SkRect::MakeWH(75, 75));
|
|
canvas->drawColor(SkColorSetRGB(0x00, 0x00, 0xFF));
|
|
##
|
|
|
|
#SeeAlso SkColorSetARGB
|
|
|
|
#Define ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Define SkColorGetA
|
|
#Line # returns Alpha component ##
|
|
|
|
#Code
|
|
###$
|
|
#define SkColorGetA(color) (((color) >> 24) & 0xFF)
|
|
$$$#
|
|
##
|
|
|
|
Returns Alpha byte from Color value.
|
|
|
|
#Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(SK_ColorRED);
|
|
for (int alpha = 255; alpha >= 0; alpha -= 17) {
|
|
paint.setAlpha(alpha);
|
|
canvas->drawRect({5, 5, 100, 20}, paint);
|
|
SkAlpha alphaInPaint = SkColorGetA(paint.getColor());
|
|
canvas->drawString(std::to_string(alphaInPaint).c_str(), 110, 18, paint);
|
|
canvas->translate(0, 15);
|
|
}
|
|
##
|
|
|
|
#SeeAlso SkPaint::getAlpha
|
|
|
|
#Define ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Define SkColorGetR
|
|
#Line # returns red component ##
|
|
|
|
#Code
|
|
###$
|
|
#define SkColorGetR(color) (((color) >> 16) & 0xFF)
|
|
$$$#
|
|
##
|
|
|
|
Returns red component of Color, from zero to 255.
|
|
|
|
#Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ##
|
|
#Return red byte ##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkPaint bgPaint;
|
|
bgPaint.setColor(0xafffffff);
|
|
canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
|
uint8_t red = SkColorGetR(source.getColor(226, 128));
|
|
canvas->drawString(std::to_string(red).c_str(), 40, 65, SkPaint());
|
|
canvas->drawLine(80, 70, 226, 128, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkColorGetG SkColorGetB
|
|
|
|
#Define ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Define SkColorGetG
|
|
#Line # returns green component ##
|
|
|
|
#Code
|
|
###$
|
|
#define SkColorGetG(color) (((color) >> 8) & 0xFF)
|
|
$$$#
|
|
##
|
|
|
|
Returns green component of Color, from zero to 255.
|
|
|
|
#Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ##
|
|
#Return green byte ##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkPaint bgPaint;
|
|
bgPaint.setColor(0xafffffff);
|
|
canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
|
uint8_t green = SkColorGetG(source.getColor(57, 192));
|
|
canvas->drawString(std::to_string(green).c_str(), 40, 65, SkPaint());
|
|
canvas->drawLine(80, 70, 57, 192, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkColorGetR SkColorGetB
|
|
|
|
#Define ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Define SkColorGetB
|
|
#Line # returns blue component ##
|
|
|
|
#Code
|
|
###$
|
|
#define SkColorGetB(color) (((color) >> 0) & 0xFF)
|
|
$$$#
|
|
##
|
|
|
|
Returns blue component of Color, from zero to 255.
|
|
|
|
#Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ##
|
|
#Return blue byte ##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkPaint bgPaint;
|
|
bgPaint.setColor(0xafffffff);
|
|
canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
|
uint8_t blue = SkColorGetB(source.getColor(168, 170));
|
|
canvas->drawString(std::to_string(blue).c_str(), 40, 65, SkPaint());
|
|
canvas->drawLine(80, 70, 168, 170, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkColorGetR SkColorGetG
|
|
|
|
#Define ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static constexpr inline SkColor SkColorSetA(SkColor c, U8CPU a)
|
|
#In Function
|
|
#Line # returns Color with transparency ##
|
|
|
|
Returns Unpremultiplied Color with red, blue, and green set from c; and alpha set
|
|
from a. Alpha component of c is ignored and is replaced by a in result.
|
|
|
|
#Param c packed RGB, eight bits per component ##
|
|
#Param a Alpha: transparent at zero, fully opaque at 255 ##
|
|
|
|
#Return Color with transparency ##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
for (int y = 0; y < 256; y += 16) {
|
|
for (int x = 0; x < 256; x += 16) {
|
|
SkColor color = source.getColor(x + 8, y + 8);
|
|
SkPaint paint;
|
|
paint.setColor(SkColorSetA(color, x + y));
|
|
canvas->drawRect(SkRect::MakeXYWH(x, y, 16, 16), paint);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso SkColorSetARGB
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Alpha_Constants
|
|
#In Constant
|
|
#Line # constants for Alpha ##
|
|
|
|
#Code
|
|
constexpr SkAlpha SK_AlphaTRANSPARENT = 0x00;
|
|
constexpr SkAlpha SK_AlphaOPAQUE = 0xFF;
|
|
##
|
|
|
|
Alpha constants are conveniences to represent fully transparent and fully
|
|
opaque colors and masks. Their use is not required.
|
|
|
|
#Const SK_AlphaTRANSPARENT 0x00
|
|
#Line # fully transparent SkAlpha ##
|
|
#Details Transparent
|
|
Represents fully transparent SkAlpha value. SkAlpha ranges from zero,
|
|
fully transparent; to 255, fully opaque.
|
|
##
|
|
#Const SK_AlphaOPAQUE 0xFF
|
|
#Line # fully opaque SkAlpha ##
|
|
#Details Opaque
|
|
Represents fully opaque SkAlpha value. SkAlpha ranges from zero,
|
|
fully transparent; to 255, fully opaque.
|
|
##
|
|
|
|
#Subtopic Transparent
|
|
|
|
#Example
|
|
#Image 1
|
|
#Height 128
|
|
#Description
|
|
Color the parts of the bitmap red if they mostly contain transparent pixels.
|
|
##
|
|
std::vector<int32_t> srcPixels;
|
|
srcPixels.resize(source.height() * source.rowBytes());
|
|
SkPixmap pixmap(SkImageInfo::MakeN32Premul(source.width(), source.height()),
|
|
&srcPixels.front(), source.rowBytes());
|
|
source.readPixels(pixmap, 0, 0);
|
|
for (int y = 0; y < 16; ++y) {
|
|
for (int x = 0; x < 16; ++x) {
|
|
int32_t* blockStart = &srcPixels.front() + y * source.width() * 16 + x * 16;
|
|
size_t transparentCount = 0;
|
|
for (int fillY = 0; fillY < source.height() / 16; ++fillY) {
|
|
for (int fillX = 0; fillX < source.width() / 16; ++fillX) {
|
|
const SkColor color = SkUnPreMultiply::PMColorToColor(blockStart[fillX]);
|
|
transparentCount += SkColorGetA(color) == SK_AlphaTRANSPARENT;
|
|
}
|
|
blockStart += source.width();
|
|
}
|
|
if (transparentCount > 200) {
|
|
blockStart = &srcPixels.front() + y * source.width() * 16 + x * 16;
|
|
for (int fillY = 0; fillY < source.height() / 16; ++fillY) {
|
|
for (int fillX = 0; fillX < source.width() / 16; ++fillX) {
|
|
blockStart[fillX] = SK_ColorRED;
|
|
}
|
|
blockStart += source.width();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso SkAlpha SK_ColorTRANSPARENT SK_AlphaOPAQUE
|
|
|
|
#Subtopic Transparent ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Opaque
|
|
|
|
#Example
|
|
#Image 1
|
|
#Height 128
|
|
std::vector<int32_t> srcPixels;
|
|
srcPixels.resize(source.height() * source.rowBytes());
|
|
SkPixmap pixmap(SkImageInfo::MakeN32Premul(source.width(), source.height()),
|
|
&srcPixels.front(), source.rowBytes());
|
|
source.readPixels(pixmap, 0, 0);
|
|
for (int y = 0; y < source.height(); ++y) {
|
|
for (int x = 0; x < source.width(); ++x) {
|
|
SkPMColor pixel = srcPixels[y * source.width() + x];
|
|
const SkColor color = SkUnPreMultiply::PMColorToColor(pixel);
|
|
if (SkColorGetA(color) == SK_AlphaOPAQUE) {
|
|
srcPixels[y * source.width() + x] = SK_ColorGREEN;
|
|
}
|
|
}
|
|
}
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
##
|
|
|
|
#SeeAlso SkAlpha SK_AlphaTRANSPARENT
|
|
|
|
#Subtopic Opaque ##
|
|
#Subtopic Alpha_Constants ##
|
|
|
|
#Subtopic Color_Constants
|
|
#In Constant
|
|
#Line # constants for Color ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
#Code
|
|
constexpr SkColor SK_ColorTRANSPARENT = SkColorSetARGB(0x00, 0x00, 0x00, 0x00);
|
|
constexpr SkColor SK_ColorBLACK = SkColorSetARGB(0xFF, 0x00, 0x00, 0x00);
|
|
constexpr SkColor SK_ColorDKGRAY = SkColorSetARGB(0xFF, 0x44, 0x44, 0x44);
|
|
constexpr SkColor SK_ColorGRAY = SkColorSetARGB(0xFF, 0x88, 0x88, 0x88);
|
|
constexpr SkColor SK_ColorLTGRAY = SkColorSetARGB(0xFF, 0xCC, 0xCC, 0xCC);
|
|
constexpr SkColor SK_ColorWHITE = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
|
|
constexpr SkColor SK_ColorRED = SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00);
|
|
constexpr SkColor SK_ColorGREEN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0x00);
|
|
constexpr SkColor SK_ColorBLUE = SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF);
|
|
constexpr SkColor SK_ColorYELLOW = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0x00);
|
|
constexpr SkColor SK_ColorCYAN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0xFF);
|
|
constexpr SkColor SK_ColorMAGENTA = SkColorSetARGB(0xFF, 0xFF, 0x00, 0xFF);
|
|
##
|
|
|
|
Color names are provided as conveniences, but are not otherwise special.
|
|
The values chosen for names may not be the same as values used by
|
|
SVG, HTML, CSS, or colors named by a platform.
|
|
|
|
#Example
|
|
###$
|
|
$Function
|
|
#define SKIA_COLOR_PAIR(name) "SK_Color" #name, SK_Color##name
|
|
$$
|
|
void draw(SkCanvas* canvas) {
|
|
struct ColorCompare {
|
|
const char* fSVGName;
|
|
SkColor fSVGColor;
|
|
const char* fSkiaName;
|
|
SkColor fSkiaColor;
|
|
} colorCompare[] = { // see https://www.w3.org/TR/SVG/types.html#ColorKeywords
|
|
{"black", SkColorSetRGB( 0, 0, 0), SKIA_COLOR_PAIR(BLACK) },
|
|
{"darkgray", SkColorSetRGB(169, 169, 169), SKIA_COLOR_PAIR(DKGRAY) },
|
|
{"gray", SkColorSetRGB(128, 128, 128), SKIA_COLOR_PAIR(GRAY) },
|
|
{"lightgray", SkColorSetRGB(211, 211, 211), SKIA_COLOR_PAIR(LTGRAY) },
|
|
{"white", SkColorSetRGB(255, 255, 255), SKIA_COLOR_PAIR(WHITE) },
|
|
{"red", SkColorSetRGB(255, 0, 0), SKIA_COLOR_PAIR(RED) },
|
|
{"green", SkColorSetRGB( 0, 128, 0), SKIA_COLOR_PAIR(GREEN) },
|
|
{"blue", SkColorSetRGB( 0, 0, 255), SKIA_COLOR_PAIR(BLUE) },
|
|
{"yellow", SkColorSetRGB(255, 255, 0), SKIA_COLOR_PAIR(YELLOW) },
|
|
{"aqua", SkColorSetRGB( 0, 255, 255), SKIA_COLOR_PAIR(CYAN) },
|
|
{"fuchsia", SkColorSetRGB(255, 0, 255), SKIA_COLOR_PAIR(MAGENTA) },
|
|
};
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
paint.setTextSize(14);
|
|
for (auto compare : colorCompare) {
|
|
paint.setStyle(SkPaint::kFill_Style);
|
|
paint.setColor(compare.fSVGColor);
|
|
canvas->drawRect({5, 5, 15, 15}, paint);
|
|
paint.setColor(SK_ColorBLACK);
|
|
canvas->drawString(compare.fSVGName, 20, 16, paint);
|
|
paint.setColor(compare.fSkiaColor);
|
|
canvas->drawRect({105, 5, 115, 15}, paint);
|
|
paint.setColor(SK_ColorBLACK);
|
|
canvas->drawString(compare.fSkiaName, 120, 16, paint);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawRect({5, 5, 15, 15}, paint);
|
|
canvas->drawRect({105, 5, 115, 15}, paint);
|
|
canvas->translate(0, 20);
|
|
}
|
|
}
|
|
$$$#
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Const SK_ColorTRANSPARENT 0x00000000
|
|
#Line # transparent Color ##
|
|
#Details Transparent
|
|
Represents fully transparent SkColor. May be used to initialize a destination
|
|
containing a mask or a non-rectangular image.
|
|
##
|
|
#Const SK_ColorBLACK 0xFF000000
|
|
#Line # black Color ##
|
|
#Details Black
|
|
Represents fully opaque black.
|
|
##
|
|
#Const SK_ColorDKGRAY 0xFF444444
|
|
#Line # dark gray Color ##
|
|
Represents fully opaque dark gray.
|
|
Note that SVG_darkgray is equivalent to 0xFFA9A9A9.
|
|
##
|
|
#Const SK_ColorGRAY 0xFF888888
|
|
#Line # gray Color ##
|
|
Represents fully opaque gray.
|
|
Note that HTML_Gray is equivalent to 0xFF808080.
|
|
##
|
|
#Const SK_ColorLTGRAY 0xFFCCCCCC
|
|
#Line # light gray Color ##
|
|
Represents fully opaque light gray. HTML_Silver is equivalent to 0xFFC0C0C0.
|
|
Note that SVG_lightgray is equivalent to 0xFFD3D3D3.
|
|
##
|
|
#Const SK_ColorWHITE 0xFFFFFFFF
|
|
#Line # white Color ##
|
|
Represents fully opaque white.
|
|
##
|
|
#Const SK_ColorRED 0xFFFF0000
|
|
#Line # red Color ##
|
|
Represents fully opaque red.
|
|
##
|
|
#Const SK_ColorGREEN 0xFF00FF00
|
|
#Line # green Color ##
|
|
Represents fully opaque green. HTML_Lime is equivalent.
|
|
Note that HTML_Green is equivalent to 0xFF008000.
|
|
##
|
|
#Const SK_ColorBLUE 0xFF0000FF
|
|
#Line # blue Color ##
|
|
Represents fully opaque blue.
|
|
##
|
|
#Const SK_ColorYELLOW 0xFFFFFF00
|
|
#Line # yellow Color ##
|
|
Represents fully opaque yellow.
|
|
##
|
|
#Const SK_ColorCYAN 0xFF00FFFF
|
|
#Line # cyan Color ##
|
|
Represents fully opaque cyan. HTML_Aqua is equivalent.
|
|
##
|
|
#Const SK_ColorMAGENTA 0xFFFF00FF
|
|
#Line # magenta Color ##
|
|
Represents fully opaque magenta. HTML_Fuchsia is equivalent.
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Transparent
|
|
|
|
#Example
|
|
#Image 3
|
|
std::vector<uint32_t> srcPixels;
|
|
constexpr int width = 256;
|
|
constexpr int height = 256;
|
|
srcPixels.resize(width * height);
|
|
SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height);
|
|
SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes());
|
|
pixmap.erase(SK_ColorTRANSPARENT);
|
|
pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } );
|
|
pixmap.erase(SK_ColorTRANSPARENT, { 48, 48, 168, 168 } );
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
canvas->drawBitmap(bitmap, 48, 48);
|
|
##
|
|
|
|
#SeeAlso SK_AlphaTRANSPARENT SkCanvas::clear
|
|
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Black
|
|
|
|
#Example
|
|
std::vector<uint32_t> srcPixels;
|
|
constexpr int width = 256;
|
|
constexpr int height = 256;
|
|
srcPixels.resize(width * height);
|
|
SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height);
|
|
SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes());
|
|
pixmap.erase(SK_ColorTRANSPARENT);
|
|
pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } );
|
|
pixmap.erase(SK_ColorBLACK, { 48, 48, 168, 168 } );
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
canvas->drawBitmap(bitmap, 48, 48);
|
|
##
|
|
|
|
#SeeAlso SK_ColorTRANSPARENT
|
|
|
|
##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic White
|
|
|
|
#Example
|
|
std::vector<uint32_t> srcPixels;
|
|
constexpr int width = 256;
|
|
constexpr int height = 256;
|
|
srcPixels.resize(width * height);
|
|
SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height);
|
|
SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes());
|
|
pixmap.erase(SK_ColorTRANSPARENT);
|
|
pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } );
|
|
pixmap.erase(SK_ColorWHITE, { 48, 48, 168, 168 } );
|
|
SkBitmap bitmap;
|
|
bitmap.installPixels(pixmap);
|
|
canvas->drawBitmap(bitmap, 0, 0);
|
|
canvas->drawBitmap(bitmap, 48, 48);
|
|
##
|
|
|
|
#SeeAlso SK_ColorTRANSPARENT
|
|
|
|
##
|
|
|
|
#Subtopic Color_Constants ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic HSV
|
|
|
|
#Subtopic Hue
|
|
Hue represents an angle, in degrees, on a color wheel. Hue has a positive value
|
|
modulo 360, where zero degrees is red.
|
|
##
|
|
|
|
#Subtopic Saturation
|
|
Saturation represents the intensity of the color. Saturation varies from zero,
|
|
with no Hue contribution; to one, with full Hue contribution.
|
|
##
|
|
|
|
#Subtopic Value
|
|
Value represents the lightness of the color. Value varies from zero, black; to
|
|
one, full brightness.
|
|
##
|
|
|
|
#Method void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3])
|
|
#In Function
|
|
#Line # converts RGB to HSV ##
|
|
|
|
Converts RGB to its HSV components.
|
|
hsv[0] contains HSV_Hue, a value from zero to less than 360.
|
|
hsv[1] contains HSV_Saturation, a value from zero to one.
|
|
hsv[2] contains HSV_Value, a value from zero to one.
|
|
|
|
#Param red red component value from zero to 255 ##
|
|
#Param green green component value from zero to 255 ##
|
|
#Param blue blue component value from zero to 255 ##
|
|
#Param hsv three element array which holds the resulting HSV components
|
|
##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
SkPaint bgPaint;
|
|
bgPaint.setColor(0xafffffff);
|
|
canvas->drawRect({20, 30, 110, 90}, bgPaint);
|
|
SkScalar hsv[3];
|
|
SkColor c = source.getColor(226, 128);
|
|
SkRGBToHSV(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c), hsv);
|
|
canvas->drawString(("h: " + std::to_string(hsv[0]).substr(0, 6)).c_str(), 27, 45, SkPaint());
|
|
canvas->drawString(("s: " + std::to_string(hsv[1]).substr(0, 6)).c_str(), 27, 65, SkPaint());
|
|
canvas->drawString(("v: " + std::to_string(hsv[2]).substr(0, 6)).c_str(), 27, 85, SkPaint());
|
|
canvas->drawLine(110, 90, 226, 128, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkColorToHSV SkHSVToColor
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void SkColorToHSV(SkColor color, SkScalar hsv[3])
|
|
#In Function
|
|
#Line # converts RGB to HSV ##
|
|
|
|
Converts ARGB to its HSV components. Alpha in ARGB is ignored.
|
|
hsv[0] contains HSV_Hue, and is assigned a value from zero to less than 360.
|
|
hsv[1] contains HSV_Saturation, a value from zero to one.
|
|
hsv[2] contains HSV_Value, a value from zero to one.
|
|
|
|
#Param color ARGB color to convert
|
|
##
|
|
#Param hsv three element array which holds the resulting HSV components
|
|
##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
for (int y = 0; y < 256; ++y) {
|
|
for (int x = 0; x < 256; ++x) {
|
|
SkScalar hsv[3];
|
|
SkColorToHSV(source.getColor(x, y), hsv);
|
|
hsv[1] = 1 - hsv[1];
|
|
SkPaint paint;
|
|
paint.setColor(SkHSVToColor(hsv));
|
|
canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso SkRGBToHSV SkHSVToColor
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3])
|
|
#In Function
|
|
#Line # converts HSV with Alpha to RGB ##
|
|
|
|
Converts HSV components to an ARGB color. Alpha is passed through unchanged.
|
|
hsv[0] represents HSV_Hue, an angle from zero to less than 360.
|
|
hsv[1] represents HSV_Saturation, and varies from zero to one.
|
|
hsv[2] represents HSV_Value, and varies from zero to one.
|
|
|
|
Out of range hsv values are pinned.
|
|
|
|
#Param alpha Alpha component of the returned ARGB color
|
|
##
|
|
#Param hsv three element array which holds the input HSV components
|
|
##
|
|
|
|
#Return ARGB equivalent to HSV
|
|
##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
for (int y = 0; y < 256; ++y) {
|
|
for (int x = 0; x < 256; ++x) {
|
|
SkColor color = source.getColor(x, y);
|
|
SkScalar hsv[3];
|
|
SkColorToHSV(color, hsv);
|
|
hsv[0] = hsv[0] + 90 >= 360 ? hsv[0] - 270 : hsv[0] + 90;
|
|
SkPaint paint;
|
|
paint.setColor(SkHSVToColor(x + y, hsv));
|
|
canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso SkColorToHSV SkRGBToHSV
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkColor SkHSVToColor(const SkScalar hsv[3])
|
|
#In Function
|
|
#Line # converts HSV to RGB ##
|
|
|
|
Converts HSV components to an ARGB color. Alpha is set to 255.
|
|
hsv[0] represents HSV_Hue, an angle from zero to less than 360.
|
|
hsv[1] represents HSV_Saturation, and varies from zero to one.
|
|
hsv[2] represents HSV_Value, and varies from zero to one.
|
|
|
|
Out of range hsv values are pinned.
|
|
|
|
#Param hsv three element array which holds the input HSV components
|
|
##
|
|
|
|
#Return RGB equivalent to HSV
|
|
##
|
|
|
|
#Example
|
|
#Image 3
|
|
canvas->drawBitmap(source, 0, 0);
|
|
for (int y = 0; y < 256; ++y) {
|
|
for (int x = 0; x < 256; ++x) {
|
|
SkColor color = source.getColor(x, y);
|
|
SkScalar hsv[3];
|
|
SkColorToHSV(color, hsv);
|
|
hsv[0] = hsv[0] + 90 >= 360 ? hsv[0] - 270 : hsv[0] + 90;
|
|
SkPaint paint;
|
|
paint.setColor(SkHSVToColor(hsv));
|
|
canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso SkColorToHSV SkRGBToHSV
|
|
|
|
#Method ##
|
|
|
|
#Subtopic HSV ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic PMColor
|
|
|
|
#Typedef uint32_t SkPMColor
|
|
#Line # defines Premultiplied Color as 32 bits ##
|
|
|
|
#Code
|
|
typedef uint32_t SkPMColor;
|
|
##
|
|
|
|
32-bit ARGB color value, Premultiplied. The byte order for this value is
|
|
configuration dependent, matching the format of kBGRA_8888_SkColorType bitmaps.
|
|
This is different from SkColor, which is Unpremultiplied, and is always in the
|
|
same byte order.
|
|
|
|
#Typedef ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
|
|
#In Function
|
|
#Line # converts Unpremultiplied ARGB to Premultiplied PMColor ##
|
|
|
|
Returns a SkPMColor value from Unpremultiplied 8-bit component values.
|
|
|
|
#Param a amount of Alpha, from fully transparent (0) to fully opaque (255) ##
|
|
#Param r amount of red, from no red (0) to full red (255) ##
|
|
#Param g amount of green, from no green (0) to full green (255) ##
|
|
#Param b amount of blue, from no blue (0) to full blue (255) ##
|
|
|
|
#Return Premultiplied Color ##
|
|
|
|
#Example
|
|
#Height 128
|
|
#Width 300
|
|
SkPMColor premultiplied = SkPreMultiplyARGB(160, 128, 160, 192);
|
|
canvas->drawString("Unpremultiplied:", 20, 20, SkPaint());
|
|
canvas->drawString("alpha=160 red=128 green=160 blue=192", 20, 40, SkPaint());
|
|
canvas->drawString("Premultiplied:", 20, 80, SkPaint());
|
|
std::string str = "alpha=" + std::to_string(SkColorGetA(premultiplied));
|
|
str += " red=" + std::to_string(SkColorGetR(premultiplied));
|
|
str += " green=" + std::to_string(SkColorGetG(premultiplied));
|
|
str += " blue=" + std::to_string(SkColorGetB(premultiplied));
|
|
canvas->drawString(str.c_str(), 20, 100, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkPreMultiplyColor
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPMColor SkPreMultiplyColor(SkColor c)
|
|
#In Function
|
|
#Line # converts Unpremultiplied Color to Premultiplied PMColor ##
|
|
|
|
Returns PMColor closest to Color c. Multiplies c RGB components by the c Alpha,
|
|
and arranges the bytes to match the format of kN32_SkColorType.
|
|
|
|
#Param c Unpremultiplied ARGB Color ##
|
|
|
|
#Return Premultiplied Color ##
|
|
|
|
#Example
|
|
#Height 128
|
|
#Width 300
|
|
SkColor unpremultiplied = SkColorSetARGB(160, 128, 160, 192);
|
|
SkPMColor premultiplied = SkPreMultiplyColor(unpremultiplied);
|
|
canvas->drawString("Unpremultiplied:", 20, 20, SkPaint());
|
|
std::string str = "alpha=" + std::to_string(SkColorGetA(unpremultiplied));
|
|
str += " red=" + std::to_string(SkColorGetR(unpremultiplied));
|
|
str += " green=" + std::to_string(SkColorGetG(unpremultiplied));
|
|
str += " blue=" + std::to_string(SkColorGetB(unpremultiplied));
|
|
canvas->drawString(str.c_str(), 20, 40, SkPaint());
|
|
canvas->drawString("Premultiplied:", 20, 80, SkPaint());
|
|
str = "alpha=" + std::to_string(SkColorGetA(premultiplied));
|
|
str += " red=" + std::to_string(SkColorGetR(premultiplied));
|
|
str += " green=" + std::to_string(SkColorGetG(premultiplied));
|
|
str += " blue=" + std::to_string(SkColorGetB(premultiplied));
|
|
canvas->drawString(str.c_str(), 20, 100, SkPaint());
|
|
##
|
|
|
|
#SeeAlso SkPreMultiplyARGB
|
|
|
|
#Method ##
|
|
|
|
#Subtopic PMColor ##
|
|
|
|
#Topic Color ##
|