| #Topic Color4f |
| #Alias Color4f_Reference ## |
| #Substitute SkColor4f |
| |
| #Struct SkPM4f |
| ## |
| |
| #Struct SkRGBA4f |
| |
| #Code |
| #Populate |
| ## |
| |
| Each component is stored as a 32-bit single precision floating point float value. |
| All values are allowed, but only the range from zero to one is meaningful. |
| |
| Components are independent of the others if defined with kUnpremul_SkAlphaType; |
| fA Alpha is may be greater or smaller than fG green, fB blue, or fR red. |
| SkColor4f is shorthand for Unpremultiplied SkRGBA4f. |
| |
| Components are connnected if defined with kPremul_SkAlphaType; |
| fA Alpha is equal to or larger than fG green, fB blue, and fR red. The values |
| stored in fG, fB, and fR combine the color component with the Alpha component. |
| |
| Values smaller than zero or larger than one are allowed. Values out of range |
| may be used with Blend_Mode so that the final component is in range. |
| |
| #Member float fR |
| #Line # red component ## |
| Single precision float for red ranges from no red (0.0) to full red (1.0). |
| ## |
| |
| #Member float fG |
| #Line # green component ## |
| Single precision float for green ranges from no green (0.0) to full green (1.0). |
| ## |
| |
| #Member float fB |
| #Line # blue component ## |
| Single precision float for blue ranges from no blue (0.0) to full blue (1.0). |
| ## |
| |
| #Member float fA |
| #Line # alpha component ## |
| Single precision float for Alpha ranges from no Alpha (0.0) to full Alpha (1.0). |
| ## |
| |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool operator==(const SkRGBA4f& other)_const |
| #Line # compares SkRGBA4f for equality ## |
| |
| Compares SkRGBA4f with other, and returns true if all components are equivalent. |
| |
| #Param other SkRGBA4f to compare ## |
| |
| #Return true if SkRGBA4f equals other ## |
| |
| #Example |
| SkColor4f colorRed = { 1, 0, 0, 1 };
|
| SkColor4f colorNamedRed = SkColor4f::FromColor(SK_ColorRED);
|
| SkDebugf("colorRed %c= colorNamedRed", colorRed == colorNamedRed ? '=' : '!');
|
| #StdOut |
| colorRed == colorNamedRed |
| ## |
| ## |
| |
| #SeeAlso operator!=(const SkRGBA4f& other)_const |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method bool operator!=(const SkRGBA4f& other)_const |
| #Line # compares SkRGBA4f for inequality ## |
| |
| Compares SkRGBA4f with other, and returns true if all components are not |
| equivalent. |
| |
| #Param other SkRGBA4f to compare ## |
| |
| #Return true if SkRGBA4f is not equal to other ## |
| |
| #Example |
| SkColor4f colorGray = { .5, .5, .5, 1 };
|
| SkColor4f colorNamedGray = SkColor4f::FromColor(SK_ColorGRAY);
|
| SkDebugf("colorGray %c= colorNamedGray ", colorGray != colorNamedGray ? '!' : '=');
|
| #StdOut |
| colorGray != colorNamedGray |
| ## |
| ## |
| |
| #SeeAlso operator==(const SkRGBA4f& other)_const |
| |
| #Method ## |
| |
| #Method SkRGBA4f operator*(float scale)_const |
| #Line # multiplies components by scale ## |
| |
| Multiplies each component by scale. Does not pin the result. |
| |
| #Param scale component multiplier ## |
| |
| #Return scaled color ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso SkBlendMode::kMultiply |
| |
| #Method ## |
| |
| #Method SkRGBA4f operator*(const SkRGBA4f& scale)_const |
| |
| Multiplies each component by scale component. Does not pin the result. |
| |
| #Param scale SkRGBA4f component multipliers ## |
| |
| #Return scaled color ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso SkBlendMode::kMultiply |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Property_Functions |
| #Line # member values ## |
| #Subtopic Property_Functions ## |
| |
| #Method const float* vec() const |
| #In Property_Functions |
| #Line # returns array of components ## |
| |
| Returns SkRGBA4f components as a read-only array. |
| |
| #Return components as read-only array ## |
| |
| #Example |
| SkColor4f color = SkColor4f::FromColor(0x884488CC);
|
| SkDebugf("red=%g green=%g blue=%g alpha=%g\n", color.fR, color.fG, color.fB, color.fA);
|
| const float* array = color.vec();
|
| SkDebugf("[0]=%g [1]=%g [2]=%g [3]=%g\n", array[0], array[1], array[2], array[3]);
|
| #StdOut |
| red=0.266667 green=0.533333 blue=0.8 alpha=0.533333
|
| [0]=0.266667 [1]=0.533333 [2]=0.8 [3]=0.533333 |
| ## |
| ## |
| |
| #SeeAlso SkColor4f |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method float* vec() |
| #In Property_Functions |
| #Line # returns array of components ## |
| |
| Returns SkRGBA4f components as a writable array. |
| |
| #Return components as writable array ## |
| |
| #Example |
| SkColor4f color = SkColor4f::FromColor(0x884488CC);
|
| SkDebugf("red=%g green=%g blue=%g alpha=%g\n", color.fR, color.fG, color.fB, color.fA);
|
| float* array = color.vec();
|
| array[3] = 1;
|
| SkDebugf("[0]=%g [1]=%g [2]=%g [3]=%g\n", array[0], array[1], array[2], array[3]); |
| #StdOut |
| red=0.266667 green=0.533333 blue=0.8 alpha=0.533333
|
| [0]=0.266667 [1]=0.533333 [2]=0.8 [3]=1 |
| ## |
| ## |
| |
| #SeeAlso SkColor4f |
| |
| #Method ## |
| |
| #Method float operator[](int index)_const |
| #Line # returns component by index ## |
| |
| Returns SkRGBA4f component by index, zero through three. index out of range |
| triggers an assert in debug builds. |
| |
| #Param index component, zero through three ## |
| #Return component by index ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso vec |
| |
| #Method ## |
| |
| #Method float& operator[](int index) |
| #Line # returns writable component reference ## |
| |
| Returns writable component reference by index, zero through three. index out of range |
| triggers an assert in debug builds. |
| |
| #Param index component, zero through three ## |
| #Return writable component reference by index ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso vec |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Utility_Functions |
| #Line # less common functions ## |
| #Subtopic Utility_Functions ## |
| |
| #Method bool isOpaque() const |
| #In Utility_Functions |
| #Line # returns if Alpha component is at maximum ## |
| |
| Returns true if Alpha component is one. Color has no transparency regardless of |
| whether color is Premultiplied or Unpremultiplied. Triggers a debugging assert |
| if Alpha not valid. |
| |
| #Return true if Alpha is one ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso vec SkColorGetA |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkRGBA4f Pin(float r, float g, float b, float a) |
| #In Utility_Functions |
| #Line # sets components to valid range ## |
| |
| Constructs and returns SkRGBA4f with each component pinned from zero to one. |
| |
| #Param r red component ## |
| #Param g green component ## |
| #Param b blue component ## |
| #Param a Alpha component ## |
| |
| #Return Color4f with valid components ## |
| |
| #Example |
| #Height 40 |
| uint32_t storage[8]; |
| SkImageInfo info = SkImageInfo::MakeN32Premul(8, 1); |
| SkPixmap pixmap(info, storage, info.minRowBytes()); |
| pixmap.erase(SK_ColorWHITE); |
| SkIRect bounds = {0, 0, 1, 1}; |
| SkColor4f colors[] = { SkColor4f::Pin(1.5, 0.45f, 0.0, 1), |
| SkColor4f::Pin(1, 0.45f, -0.25, 1), |
| {1.5, 0.45f, 0.0, 1}, |
| {1, 0.45f, -0.25, 1}, |
| }; |
| for (auto color4f : colors) { |
| pixmap.erase(color4f, &bounds); |
| bounds.offset(2, 0); |
| } |
| SkBitmap bitmap; |
| canvas->scale(20, 20); |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| ## |
| |
| #SeeAlso pin() FromColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkRGBA4f pin() const |
| #In Utility_Functions |
| #Line # sets components to valid range ## |
| |
| Returns SkRGBA4f with all components in the range from zero to one. |
| |
| #Return SkRGBA4f with valid components ## |
| |
| #Example |
| #Height 40 |
| uint32_t storage[8]; |
| SkImageInfo info = SkImageInfo::MakeN32Premul(8, 1); |
| SkPixmap pixmap(info, storage, info.minRowBytes()); |
| pixmap.erase(SK_ColorWHITE); |
| SkIRect bounds = {0, 0, 1, 1}; |
| SkColor4f colors[] = { {1.5, 0.45f, 0.0, 1}, |
| {1, 0.45f, -0.25, 1}, |
| }; |
| for (auto color4f : colors) { |
| pixmap.erase(color4f, &bounds); |
| bounds.offset(2, 0); |
| pixmap.erase(color4f.pin(), &bounds); |
| bounds.offset(2, 0); |
| } |
| SkBitmap bitmap; |
| canvas->scale(20, 20); |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| ## |
| |
| #SeeAlso Pin |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkRGBA4f FromColor(SkColor) |
| #In Utility_Functions |
| #Line # sets components from Color ## |
| |
| Converts to closest SkRGBA4f. |
| |
| #Param SkColor Color with Alpha, red, blue, and green components ## |
| |
| #Return SkRGBA4f equivalent ## |
| |
| #Example |
| uint8_t red = 77, green = 101, blue = 153, alpha = 43;
|
| SkColor argb = SkColorSetARGB(alpha, red, green, blue);
|
| SkColor4f color4f = SkColor4f::FromColor(argb);
|
| SkDebugf("red=%g green=%g blue=%g alpha=%g\n", color4f.fR, color4f.fG, color4f.fB, color4f.fA);
|
| SkColor fromColor4f = color4f.toSkColor();
|
| SkDebugf("red=%d green=%d blue=%d alpha=%d\n", SkColorGetR(fromColor4f),
|
| SkColorGetG(fromColor4f), SkColorGetB(fromColor4f), SkColorGetA(fromColor4f)); |
| #StdOut |
| red=0.301961 green=0.396078 blue=0.6 alpha=0.168627
|
| red=77 green=101 blue=153 alpha=43 |
| ## |
| ## |
| |
| #SeeAlso toSkColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkColor toSkColor() const |
| #In Utility_Functions |
| #Line # returns closest Color ## |
| |
| Converts to closest SkColor. |
| |
| #Return closest Color ## |
| |
| #Example |
| float red = 0.07, green = 0.13, blue = 0.32, alpha = 0.17;
|
| SkColor4f color4f = { red, green, blue, alpha };
|
| SkColor argb = color4f.toSkColor();
|
| SkDebugf("red=%d green=%d blue=%d alpha=%d\n", SkColorGetR(argb),
|
| SkColorGetG(argb), SkColorGetB(argb), SkColorGetA(argb)); |
| SkColor4f fromSkColor = SkColor4f::FromColor(argb);
|
| SkDebugf("red=%g green=%g blue=%g alpha=%g\n", fromSkColor.fR, fromSkColor.fG,
|
| fromSkColor.fB, fromSkColor.fA);
|
| #StdOut
|
| red=18 green=33 blue=82 alpha=43
|
| red=0.0705882 green=0.129412 blue=0.321569 alpha=0.168627
|
| ##
|
| ## |
| |
| #SeeAlso FromColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static SkRGBA4f FromPMColor(SkPMColor) |
| #In Utility_Functions |
| #Line # converts from Premultiplied Color ## |
| |
| Converts from Premultiplied integer components to Unpremultiplied float |
| components. |
| |
| #Param SkPMColor Premultiplied color ## |
| |
| #Return Unpremultiplied color ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso FromColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkRGBA4f<kPremul_SkAlphaType> premul() const |
| #In Utility |
| #Line # returns Premultiplied color ## |
| |
| Returns SkColor4f with all components premultiplied by Alpha. |
| |
| #Return Premultiplied color ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso unpremul |
| |
| #Method ## |
| |
| #Method SkRGBA4f<kUnpremul_SkAlphaType> unpremul() const |
| #In Utility |
| #Line # returns Unpremultiplied color ## |
| |
| Returns SkRGBA4f with all components independent of Alpha. |
| |
| #Return Unpremultiplied color ## |
| |
| #NoExample |
| ## |
| |
| #SeeAlso premul |
| |
| #Method ## |
| |
| #Struct ## |
| |
| #Typedef SkRGBA4f SkColor4f |
| #Line # defines Unpremultiplied Color using floats ## |
| |
| #Code |
| using SkColor4f = SkRGBA4f<kUnpremul_SkAlphaType>; |
| ## |
| |
| ## |
| |
| #Topic Color4f ## |