Pixel Conversion

|=================================================Pixels.h=================================================|

#define RED_3_3_2 0xE0
#define GRN_3_3_2 0x1C
#define BLU_3_3_2 0x03

#define RED_5_6_5 0xF800
#define GRN_5_6_5 0x07E0
#define BLU_5_6_5 0x001F

#define RED_4_4_4_4 0xF000
#define GRN_4_4_4_4 0x0F00
#define BLU_4_4_4_4 0x00F0
#define ALP_4_4_4_4 0x000F

#define RED_8_8_8_8 0xFF000000
#define GRN_8_8_8_8 0x00FF0000
#define BLU_8_8_8_8 0x0000FF00
#define ALP_8_8_8_8 0x000000FF

#define RED_8_8_8 RED_8_8_8_8
#define GRN_8_8_8 GRN_8_8_8_8
#define BLU_8_8_8 BLU_8_8_8_8

#define RED_10_10_10 0xFFC00000
#define GRN_10_10_10 0x003FF000
#define BLU_10_10_10 0x00000FFC

#define RED_16_16_16_16 0xFFFF000000000000 //some people use 64-bit color
#define GRN_16_16_16_16 0x0000FFFF00000000
#define BLU_16_16_16_16 0x00000000FFFF0000
#define ALP_16_16_16_16 0x000000000000FFFF

enum class PIXEL_FORMAT : char {
    PALETTE,
    RGB,
    RGBA
};

template<unsigned bit_depth, PIXEL_FORMAT fmt> struct Pixel {};

template<> struct Pixel<8, PIXEL_FORMAT::RGB> {
    unsigned char color;
    Pixel(unsigned char red, unsigned char green, unsigned char blue) {
        color = 0xFF & (((red << 5) & RED_3_3_2) & ((green << 2) & GRN_3_3_2) & (blue & BLU_3_3_2));
    }

    Pixel(unsigned char clr) { color = clr; }

    Pixel<16, PIXEL_FORMAT::RGB> convert_to_rgb16() {
        unsigned char red, grn, blu;
        red = ((color & RED_3_3_2) >> 5);
        grn = ((color & GRN_3_3_2) >> 2);
        blu = (color & BLU_3_3_2);

        red = ((red/7) * 31); //5
        grn = ((grn/7) * 63); //6
        blu = ((blu/3) * 31); //5

        Pixel<16, PIXEL_FORMAT::RGB> _16rgb(red, grn, blu);  //compiler throws an error here
        return _16rgb;
    }
};

template<> struct Pixel<16, PIXEL_FORMAT::RGB> {
    unsigned short color;
    Pixel(unsigned char red, unsigned char green, unsigned char blue) {
        color = (0xFFFF & (((red << 11) & RED_5_6_5) & ((green << 5) & GRN_5_6_5) & (blue & BLU_5_6_5)));
    }
    Pixel(short clr) { color = clr; }
};


|=================================================Canvas.h=================================================|

#include "Pixels.h"

template< typename PixelType > struct Layer {   //will be a base for Canvas
    unsigned int width, height;
    PixelType** pixels;

    Layer(unsigned int width, unsigned int height, unsigned int init_color = 0xFFFFFFFF);
    Layer(PixelType** pixels);
    Layer();
    ~Layer();
    Layer(const Layer& layer);

    PixelType pixel_at(unsigned int x, unsigned int y);
    void modify_pixel(unsigned int x, unsigned int y, bool add, PixelType pix);
    void replace_pixel(unsigned int x, unsigned int y, PixelType pix);
    template<unsigned int bit_depth, PIXEL_FORMAT fmt> Layer<Pixel<bit_depth, fmt>> convert_pixels() {
    Pixel<bit_depth, fmt>** new_pixels;
    new_pixels = new Pixel<bit_depth, fmt>*[height];
    for(int y = 0; y < height; y++)
        new_pixels[y] = new Pixel<bit_depth, fmt>[width];
    for(int y = 0; y < height; y++ {
        for(int x = 0; x < width; x++) {
        new_pixels[y][x] = pixels[y][x].convert_to<bit_depth, fmt>(); //make a template wrapper for the conversion methods?
        }
    }
    return Layer(new_pixels);
};