color_storage.h

#pragma once
 
#include <vector>
#include "color.h"
 
#include "lib_begin.h"
 
namespace cgv {
        namespace media {
                enum ColorType {
                        CT_RGB8,
                        CT_RGBA8,
                        CT_RGB,
                        CT_RGBA
                };
 
                template <typename T> struct color_storage_traits {};
                template <> struct color_storage_traits<color<float, RGB> > { static const ColorType color_type = CT_RGB; };
                template <> struct color_storage_traits<color<float, RGB, OPACITY> > { static const ColorType color_type = CT_RGBA; };
                template <> struct color_storage_traits<color<unsigned char, RGB> > { static const ColorType color_type = CT_RGB8; };
                template <> struct color_storage_traits<color<unsigned char, RGB, OPACITY> > { static const ColorType color_type = CT_RGBA8; };
 
                struct color_storage_types
                {
                public:                 
                        typedef color<float, RGB> rgb;
                        typedef color<float, RGB, OPACITY> rgba;
                        typedef color<unsigned char, RGB> rgb8;
                        typedef color<unsigned char, RGB, OPACITY> rgba8;
                };
 
                class abst_color_storage : public color_storage_types
                {
                protected:
                        // type of color stored in storage
                        ColorType color_type;
                public:
                        abst_color_storage(ColorType _color_type);
                        virtual ~abst_color_storage();
                        ColorType get_color_type() const;
                        size_t get_color_size() const;
                        virtual abst_color_storage* clone() const = 0;
                        virtual size_t get_nr_colors() const = 0;
                        virtual void resize(size_t nr_colors) = 0;
                        virtual const void* get_data_ptr() const = 0;
                        virtual const void* get_data_vector_ptr() const = 0;
                        virtual void set_color(size_t i, const void* col_ptr) = 0;
                        virtual void set_color(size_t i, const rgb& col) = 0;
                        virtual void set_color(size_t i, const rgba& col) = 0;
                        virtual void set_color(size_t i, const rgb8& col) = 0;
                        virtual void set_color(size_t i, const rgba8& col) = 0;
                        virtual void put_color(size_t i, void* col_ptr) const = 0;
                        virtual void put_color(size_t i, rgb& col) const = 0;
                        virtual void put_color(size_t i, rgba& col) const = 0;
                        virtual void put_color(size_t i, rgb8& col) const = 0;
                        virtual void put_color(size_t i, rgba8& col) const = 0;
                };
 
                template <typename C>
                class color_storage : public abst_color_storage
                {
                public:
                        std::vector<C> colors;
                        color_storage() : abst_color_storage(color_storage_traits<C>::color_type) { }
                        color_storage(const color_storage<C>& csm) : abst_color_storage(color_storage_traits<C>::color_type),
                                colors(csm.colors) { }
                        template <typename C1>
                        color_storage(const color_storage<C1>& csm) : abst_color_storage(color_storage_traits<C>::color_type) {
                                for (const auto& col : csm.colors)
                                        colors.push_back(col);
                        }
                        color_storage(const abst_color_storage& acsm) : abst_color_storage(color_storage_traits<C>::color_type) {
                                switch (acsm.get_color_type()) {
                                case CT_RGB:   new (this) color_storage<C>(static_cast<const color_storage<rgb>&>(acsm)); break;
                                case CT_RGBA:  new (this) color_storage<C>(static_cast<const color_storage<rgba>&>(acsm)); break;
                                case CT_RGB8:  new (this) color_storage<C>(static_cast<const color_storage<rgb8>&>(acsm)); break;
                                case CT_RGBA8: new (this) color_storage<C>(static_cast<const color_storage<rgba8>&>(acsm)); break;
                                }
                        }
                        abst_color_storage* clone() const {
                                return new color_storage(*this);
                        }
                        // implementation of vector access passes interface to std::vector class
                        size_t get_nr_colors() const { return colors.size(); }
                        void resize(size_t nr_colors) { colors.resize(nr_colors); }
                        const void* get_data_ptr() const { return &colors.front(); }
                        const void* get_data_vector_ptr() const { return &colors; }
                        // implementation of color access uses type conversion operators implemented for color class
                        void set_color(size_t i, const void* col_ptr) { colors[i] = *reinterpret_cast<const C*>(col_ptr); }
                        void set_color(size_t i, const rgb& col) { colors[i] = col; }
                        void set_color(size_t i, const rgba& col) { colors[i] = col; }
                        void set_color(size_t i, const rgb8& col) { colors[i] = col; }
                        void set_color(size_t i, const rgba8& col) { colors[i] = col; }
                        void put_color(size_t i, void* col_ptr) const { *reinterpret_cast<C*>(col_ptr) = colors[i]; }
                        void put_color(size_t i, rgb& col) const { col = colors[i]; }
                        void put_color(size_t i, rgba& col) const { col = colors[i]; }
                        void put_color(size_t i, rgb8& col) const { col = colors[i]; }
                        void put_color(size_t i, rgba8& col) const { col = colors[i]; }
                };
        }
}
 
#include <cgv/config/lib_end.h>