What is a good way to store color? - c++

Question

I started to make "game of life" and I thought, what if I could have more states than 1 or 0.
But then I need different colors. I want the colors to be linked to a grid/object (the grid is a class).
What is a good/decent way to store color pallets for fast/easy access?
My current less than ideal solution was to have 4 pointers to memory for each red, green, blue and alpha value.
In my class I had a function to set the color of value v to rgba:
SetColor(v, r, g, b, a) //Set v to the appropriate color values
I would like to keep this function to easily modify a color.

Answer 1

What I use is something really simple: 4 floats
struct Color {
float r, g, b, a;
};
Then, you can have something like a color pallete:
// a Palette of 8 colors:
using palette_t = std::array<Color, 8>
palette_t myPalette { /* ... */ };
Then, in your grid or object class, you can reference the color with an index:
struct Grid {
// lot's of code
private:
std::size_t colorIndex = 0;
};
But then you asked how to have easy access to the color (I guess the easy access is from within the Grid class)
There is a lot of solution that can exists, and most will depend of your project structure. This is one idea many others. I hope it will inspire you.
You can store a function that return the right color:
struct Grid {
// lot's of code
private:
std::size_t colorIndex = 0;
std::function<Color(std::size_t)> color;
};
And then, have something that create your grid correctly:
struct GridCreator {
GridCreator(const palette_t& aPalette) : palette{aPalette} {}
Grid create(std::size_t color) const {
Grid grid;
// create the grid
grid.color = [this](std::size_t index) {
return palette[index];
};
return grid;
}
private:
const palette_t& palette;
};
Then you got free access to your color palette without directly knowing that the palette exists from the Grid class.

Answer 2

Have an array of colors:
std::vector<std::array<unsigned char, 4>> palette {
{255, 0, 0, 255}, // red
{0, 255, 0, 255}, // green
{0, 0, 255, 255}, // blue
};
Then for each field store the index in the array (of type size_t). Example:
auto id = field[5][2];
auto color = palette[id];
auto r = color[0], alpha = color[3];
Changing a color is as simple as:
palette[id] = {255, 0, 0, 127};
For adding new colors, use:
palette.push_back({255, 0, 0, 127}).
Alternatively, you can define a simple struct so that you can use color.r, color.alpha etc. and write a constructor for easy color creation.
Mind this example is C++11 code.

Answer 3

Enums are perfect for Colors kind of structure.
More code readability.
Better compiler-time optimizations.
enum Color { red, green, blue };
Color r = red;
switch(r)
{
case red : std::cout << "red\n"; break;
case green: std::cout << "green\n"; break;
case blue : std::cout << "blue\n"; break;
}
For your special case.
You can store color for each point as a single integer.
uint32_t point_color = field[5][2].color;
unsigned char* color = (unsigned char*)point_color[id];
auto r = color[0], alpha = color[3];
/////
void SetColor(uint32_t& point_color,unsigned char r,
unsigned char g,unsigned char b,unsigned char a){
point_color=r | (b*(1<<8)) | (g*(1<<16)) | (a*(1<<24));
}
Pros of this structure
lesser messy.
faster bit operations only.
lesser memory.

Answer 4

Your question is dualistic:
What is a good way to store color?
what is a good/decent way to store color pallets?
If you really only want to store a colour, my advise would be not to store the colours as references, but to store the RGB values in one INT32 inside a class where you can get and set the Reg / Green / Blue values. Compare this with how .NET does this.
The advantage of this method is that it does no more space than using pointers and it is fast in get / set / comparisons.
A color pallette is a collection of colours. This is quite often used if you want to switch all used colours into a different colour. For instance if you want all light-blue colours in to misty-blue colours, and all fire-red colours into brick-red.
This is used by defining a palette as a pre-defined sized array or RGB values. Historically a palette contains 16, 64, or 256 values, or sometimes 2 if you only want black/white pictures.
If you use a palette, every dot in your grid has an index in your palette array and your grid has a current pallette. The RGB value of point X of grid G is then G.CurrentPallette[X.PaletIndex]. Changing all colours of your grid at once means switching to a different palette: G.CurrentPalette = otherPalette. This is a really fast and efficient way of changing the colours in your grid
Whether to use the RGB method or the Palette method depends on what you want:
Do you only want to use a subset of all possible colours, and do you want to change the complete subset into a different subset: use the Palette method
Do you want to change the colour of dots with a certain state, for instance change all yellow dots to green, use the palette method: change the color yellow in your palette to green
However, if you only want to change individual dots on your grid it is probably more efficient to use the RGB method.

Answer 5

any color value has an interval from 0 through 255 so you need 3 unsigned char variables and another one for alph. we make a whole thing, mapping them an a struct:
typedef struct Color
{
unsigned char _ucRed;
unsigned char _ucGreen;
unsigned char _ucBlue;
unsigned char _ucAlpha;
}COLOR;