* Copyright 2001-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* DarkWyrm <bpmagic@columbus.rr.com>
*/
#include "RGBColor.h"
#include "SystemPalette.h"
#include <stdio.h>
#include <stdlib.h>
\brief An approximation of 31/255, which is needed for converting from 32-bit
colors to 16-bit and 15-bit.
*/
#define RATIO_8_TO_5_BIT .121568627451
\brief An approximation of 63/255, which is needed for converting from 32-bit
colors to 16-bit.
*/
#define RATIO_8_TO_6_BIT .247058823529
\brief An approximation of 255/31, which is needed for converting from 16-bit
and 15-bit colors to 32-bit.
*/
#define RATIO_5_TO_8_BIT 8.22580645161
\brief An approximation of 255/63, which is needed for converting from 16-bit
colors to 32-bit.
*/
#define RATIO_6_TO_8_BIT 4.04761904762
#if 0
\brief Function for easy conversion of 16-bit colors to 32-bit
\param col Pointer to an rgb_color.
\param color RGB16 color
This function will do nothing if passed a NULL 32-bit color.
*/
void
SetRGBColor16(rgb_color *col,uint16 color)
{
if(!col)
return;
uint16 r16,g16,b16;
col->alpha=0;
r16= (color >> 11) & 31;
g16= (color >> 5) & 63;
b16= color & 31;
col->red=uint8(r16 * RATIO_5_TO_8_BIT);
col->green=uint8(g16 * RATIO_6_TO_8_BIT);
col->blue=uint8(b16 * RATIO_5_TO_8_BIT);
}
#endif
\brief Finds the index of the closest matching color in a rgb_color palette array
\param palette Array of 256 rgb_color objects
\param color Color to match
\return Index of the closest matching color
Note that passing a NULL palette will always return 0 and passing an array of less
than 256 rgb_colors will cause a crash.
*/
static uint8
FindClosestColor(const rgb_color *palette, rgb_color color)
{
if (!palette)
return 0;
uint16 cindex = 0, cdelta = 765, delta = 765;
for (uint16 i = 0; i < 256; i++) {
const rgb_color *c = &(palette[i]);
delta = abs(c->red-color.red) + abs(c->green-color.green)
+ abs(c->blue-color.blue);
if (delta == 0) {
cindex = i;
break;
}
if (delta < cdelta) {
cindex = i;
cdelta = delta;
}
}
return (uint8)cindex;
}
\brief Constructs a RGBA15 color which best matches a given 32-bit color
\param color Color to match
\return The closest matching color's value
Format is ARGB, 1:5:5:5
*/
static uint16
FindClosestColor15(rgb_color color)
{
uint16 r16 = uint16(color.red * RATIO_8_TO_5_BIT);
uint16 g16 = uint16(color.green * RATIO_8_TO_5_BIT);
uint16 b16 = uint16(color.blue * RATIO_8_TO_5_BIT);
uint16 color16 = color.alpha > 127 ? 0x8000 : 0;
color16 |= r16 << 10;
color16 |= g16 << 5;
color16 |= b16;
return color16;
}
\brief Constructs a RGB16 color which best matches a given 32-bit color
\param color Color to match
\return The closest matching color's value
Format is RGB, 5:6:5
*/
static uint16
FindClosestColor16(rgb_color color)
{
uint16 r16 = uint16(color.red * RATIO_8_TO_5_BIT);
uint16 g16 = uint16(color.green * RATIO_8_TO_6_BIT);
uint16 b16 = uint16(color.blue * RATIO_8_TO_5_BIT);
uint16 color16 = r16 << 11;
color16 |= g16 << 5;
color16 |= b16;
return color16;
}
\brief Create an RGBColor from specified values
\param red red
\param green green
\param blue blue
\param alpha alpha, defaults to 255
*/
RGBColor::RGBColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
SetColor(r,g,b,a);
}
\brief Create an RGBColor from specified values
\param red red
\param green green
\param blue blue
\param alpha alpha, defaults to 255
*/
RGBColor::RGBColor(int r, int g, int b, int a)
{
SetColor(r, g, b, a);
}
\brief Create an RGBColor from an rgb_color
\param color color to initialize from
*/
RGBColor::RGBColor(const rgb_color &color)
{
SetColor(color);
}
#if 0
\brief Create an RGBColor from a 16-bit RGBA color
\param color color to initialize from
*/
RGBColor::RGBColor(uint16 color)
{
SetColor(color);
}
#endif
\brief Create an RGBColor from an index color
\param color color to initialize from
*/
RGBColor::RGBColor(uint8 color)
{
SetColor(color);
}
\brief Copy Contructor
\param color color to initialize from
*/
RGBColor::RGBColor(const RGBColor &color)
{
fColor32 = color.fColor32;
fColor16 = color.fColor16;
fColor15 = color.fColor15;
fColor8 = color.fColor8;
fUpdate8 = color.fUpdate8;
fUpdate15 = color.fUpdate15;
fUpdate16 = color.fUpdate16;
}
\brief Create an RGBColor with the values(0,0,0,0)
*/
RGBColor::RGBColor()
{
SetColor(0, 0, 0, 0);
}
\brief Returns the color as the closest 8-bit color in the palette
\return The palette index for the current color
*/
uint8
RGBColor::GetColor8() const
{
if (fUpdate8) {
fColor8 = FindClosestColor(SystemPalette(), fColor32);
fUpdate8 = false;
}
return fColor8;
}
\brief Returns the color as the closest 15-bit color
\return 15-bit value of the current color plus 1-bit alpha
*/
uint16
RGBColor::GetColor15() const
{
if (fUpdate15) {
fColor15 = FindClosestColor15(fColor32);
fUpdate15 = false;
}
return fColor15;
}
\brief Returns the color as the closest 16-bit color
\return 16-bit value of the current color
*/
uint16
RGBColor::GetColor16() const
{
if (fUpdate16) {
fColor16 = FindClosestColor16(fColor32);
fUpdate16 = false;
}
return fColor16;
}
\brief Returns the color as a 32-bit color
\return current color, including alpha
*/
rgb_color
RGBColor::GetColor32() const
{
return fColor32;
}
\brief Set the object to specified values
\param red red
\param green green
\param blue blue
\param alpha alpha, defaults to 255
*/
void
RGBColor::SetColor(uint8 r, uint8 g, uint8 b, uint8 a)
{
fColor32.red = r;
fColor32.green = g;
fColor32.blue = b;
fColor32.alpha = a;
fUpdate8 = fUpdate15 = fUpdate16 = true;
}
\brief Set the object to specified values
\param red red
\param green green
\param blue blue
\param alpha alpha, defaults to 255
*/
void
RGBColor::SetColor(int r, int g, int b, int a)
{
fColor32.red = (uint8)r;
fColor32.green = (uint8)g;
fColor32.blue = (uint8)b;
fColor32.alpha = (uint8)a;
fUpdate8 = fUpdate15 = fUpdate16 = true;
}
#if 0
\brief Set the object to specified value
\param col16 color to copy
*/
void
RGBColor::SetColor(uint16 col16)
{
fColor16 = col16;
SetRGBColor(&fColor32, col16);
fUpdate8 = true;
fUpdate15 = true;
fUpdate16 = false;
}
#endif
\brief Set the object to specified index in the palette
\param col8 color to copy
*/
void
RGBColor::SetColor(uint8 col8)
{
fColor8 = col8;
fColor32 = SystemPalette()[col8];
fUpdate8 = false;
fUpdate15 = true;
fUpdate16 = true;
}
\brief Set the object to specified color
\param color color to copy
*/
void
RGBColor::SetColor(const rgb_color &color)
{
fColor32 = color;
fUpdate8 = fUpdate15 = fUpdate16 = true;
}
\brief Set the object to specified color
\param color color to copy
*/
void
RGBColor::SetColor(const RGBColor &color)
{
fColor32 = color.fColor32;
fColor16 = color.fColor16;
fColor15 = color.fColor15;
fColor8 = color.fColor8;
fUpdate8 = color.fUpdate8;
fUpdate15 = color.fUpdate15;
fUpdate16 = color.fUpdate16;
}
\brief Set the object to specified color
\param color color to copy
*/
const RGBColor&
RGBColor::operator=(const RGBColor &color)
{
fColor32 = color.fColor32;
fColor16 = color.fColor16;
fColor15 = color.fColor15;
fColor8 = color.fColor8;
fUpdate8 = color.fUpdate8;
fUpdate15 = color.fUpdate15;
fUpdate16 = color.fUpdate16;
return *this;
}
\brief Set the object to specified color
\param color color to copy
*/
const RGBColor&
RGBColor::operator=(const rgb_color &color)
{
fColor32 = color;
fUpdate8 = fUpdate15 = fUpdate16 = true;
return *this;
}
\brief Prints the 32-bit values of the color to standard out
*/
void
RGBColor::PrintToStream(void) const
{
printf("RGBColor(%u,%u,%u,%u)\n",
fColor32.red, fColor32.green, fColor32.blue, fColor32.alpha);
}
\brief Overloaded comaparison
\return true if all color elements are exactly equal
*/
bool
RGBColor::operator==(const rgb_color &color) const
{
return fColor32.red == color.red
&& fColor32.green == color.green
&& fColor32.blue == color.blue
&& fColor32.alpha == color.alpha;
}
\brief Overloaded comaparison
\return true if all color elements are exactly equal
*/
bool
RGBColor::operator==(const RGBColor &color) const
{
return fColor32.red == color.fColor32.red
&& fColor32.green == color.fColor32.green
&& fColor32.blue == color.fColor32.blue
&& fColor32.alpha == color.fColor32.alpha;
}
bool
RGBColor::operator!=(const rgb_color &color) const
{
return fColor32.red != color.red
|| fColor32.green != color.green
|| fColor32.blue != color.blue
|| fColor32.alpha != color.alpha;
}
bool
RGBColor::operator!=(const RGBColor &color) const
{
return fColor32.red != color.fColor32.red
|| fColor32.green != color.fColor32.green
|| fColor32.blue != color.fColor32.blue
|| fColor32.alpha != color.fColor32.alpha;
}
bool
RGBColor::IsTransparentMagic() const
{
return *this == B_TRANSPARENT_COLOR;
}
