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; };

        class abst_color_storage
        {
        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* ref_data_ptr() = 0;
            virtual void* ref_data_vector_ptr() = 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; }
            void* ref_data_ptr() { return &colors.front(); }
            void* ref_data_vector_ptr() { 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>