495 lines
9.0 KiB
C++
495 lines
9.0 KiB
C++
/*
|
|
* 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;
|
|
|
|
// alpha's the easy part
|
|
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);
|
|
|
|
// start with alpha value
|
|
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;
|
|
}
|
|
|
|
|
|
// #pragma mark -
|
|
|
|
|
|
/*!
|
|
\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
|
|
{
|
|
// TODO: validate this for B_CMAP8 for example
|
|
return *this == B_TRANSPARENT_COLOR;
|
|
}
|