Color.hpp

Go to the documentation of this file.

//
// Created by robin on 09.08.2019.
//
 
#ifndef TILESON_COLOR_HPP
#define TILESON_COLOR_HPP
 
#include <type_traits>
#include <cstdint>
#include <string>
 
namespace tson
{
 
    template<typename T>
    class Color
    {
 
        public:
            inline explicit Color(const std::string &color)
            {
                parseHexString(color);
            }
            inline Color(T red, T green, T blue, T alpha);
            inline Color() { r = g = b = 0; a = 255; }
 
            inline bool operator==(const Color &rhs) const;
            inline bool operator==(const std::string &rhs) const;
            inline bool operator!=(const Color &rhs) const;
 
            inline Color<float> asFloat();
            inline Color<uint8_t> asInt();
 
            T r;
            T g;
            T b;
            T a;
 
        private:
            void parseHexString(const std::string &color)
            {
                if constexpr (std::is_same<T, float>::value)
                {
                    if (color.size() == 9)
                    {
                        a = (float) std::stoi(color.substr(1, 2), nullptr, 16) / 255;
                        r = (float) std::stoi(color.substr(3, 2), nullptr, 16) / 255;
                        g = (float) std::stoi(color.substr(5, 2), nullptr, 16) / 255;
                        b = (float) std::stoi(color.substr(7, 2), nullptr, 16) / 255;
                    }
                    else if (color.size() == 7)
                    {
                        r = (float) std::stoi(color.substr(1, 2), nullptr, 16) / 255;
                        g = (float) std::stoi(color.substr(3, 2), nullptr, 16) / 255;
                        b = (float) std::stoi(color.substr(5, 2), nullptr, 16) / 255;
                        a = 1.f;
                    }
                }
                else if constexpr (std::is_same<T, uint8_t>::value)
                {
                    if (color.size() == 9)
                    {
                        a = static_cast<uint8_t>(std::stoi(color.substr(1, 2), nullptr, 16));
                        r = static_cast<uint8_t>(std::stoi(color.substr(3, 2), nullptr, 16));
                        g = static_cast<uint8_t>(std::stoi(color.substr(5, 2), nullptr, 16));
                        b = static_cast<uint8_t>(std::stoi(color.substr(7, 2), nullptr, 16));
                    }
                    else if (color.size() == 7)
                    {
                        r = static_cast<uint8_t>(std::stoi(color.substr(1, 2), nullptr, 16));
                        g = static_cast<uint8_t>(std::stoi(color.substr(3, 2), nullptr, 16));
                        b = static_cast<uint8_t>(std::stoi(color.substr(5, 2), nullptr, 16));
                        a = 255;
                    }
                }
            }
 
    };
 
    typedef Color<uint8_t> Colori;
    typedef Color<float> Colorf;
 
    template<typename T>
    tson::Colorf Color<T>::asFloat()
    {
        if constexpr (std::is_same<T, float>::value)
            *this;
        else
            return tson::Colorf((float) r / 255, (float) g / 255, (float) b / 255, (float) a / 255);
    }
 
    template<typename T>
    tson::Colori Color<T>::asInt()
    {
        if constexpr (std::is_same<T, float>::value)
            return tson::Colori(static_cast<std::uint8_t>((float) r * 255),
                              static_cast<std::uint8_t>((float) g * 255),
                              static_cast<std::uint8_t>((float) b * 255),
                              static_cast<std::uint8_t>((float) a * 255));
        else
            *this;
    }
 
    template<typename T>
    Color<T>::Color(T red, T green, T blue, T alpha)
    {
        r = red;
        g = green;
        b = blue;
        a = alpha;
    }
 
    template<typename T>
    bool Color<T>::operator==(const std::string &rhs) const {
        Color other {rhs};
        return *this == other;
    }
 
    template<typename T>
    bool Color<T>::operator==(const Color &rhs) const
    {
        return r == rhs.r &&
               g == rhs.g &&
               b == rhs.b &&
               a == rhs.a;
    }
 
    template<typename T>
    bool Color<T>::operator!=(const Color &rhs) const
    {
        return !(rhs == *this);
    }
 
 
 
 
}
 
#endif //TILESON_COLOR_HPP