Program Listing for File color.h

↰ Return to documentation for file (include\api-types\color.h)

/******************************************************************************

© Intel Corporation.

This software and the related documents are Intel copyrighted materials,
and your use of them is governed by the express license under which they
were provided to you ("License"). Unless the License provides otherwise,
you may not use, modify, copy, publish, distribute, disclose or transmit
this software or the related documents without Intel's prior written
permission.

 This software and the related documents are provided as is, with no express
or implied warranties, other than those that are expressly stated in the
License.

******************************************************************************/

#pragma once

#include <cassert>
#include <cstdint>
#include <tuple>

namespace gpa {
namespace api_types {
namespace detail {

template<typename T>
struct BasicColor
{
    static size_t constexpr ChannelCount{4};

    inline BasicColor(
        T const& _r = {},
        T const& _g = {},
        T const& _b = {},
        T const& _a = {})
        : r{_r}
        , g{_g}
        , b{_b}
        , a{_a}
    {
    }

    BasicColor(BasicColor<T> const& other) = default;

    BasicColor<T>& operator=(BasicColor<T> const& other) = default;

    inline T const& operator[](size_t index) const
    {
        switch (index) {
        case 0:
            return r;
        case 1:
            return g;
        case 2:
            return b;
        case 3:
            return a;
        default: {
            assert(index < ChannelCount && "Index out of range");
            static T dummy{};
            return dummy;
        }
        }
    }

    inline T& operator[](size_t index)
    {
        auto constThis = const_cast<BasicColor<T> const*>(this);
        return const_cast<T&>((*constThis)[index]);
    }

    T r{};
    T g{};
    T b{};
    T a{};
};

template<typename T>
inline bool operator==(BasicColor<T> const& lhs, BasicColor<T> const& rhs)
{
    return lhs.r == rhs.r &&
           lhs.g == rhs.g &&
           lhs.b == rhs.b &&
           lhs.a == rhs.a;
}

template<typename T>
inline bool operator!=(BasicColor<T> const& lhs, BasicColor<T> const& rhs)
{
    return !(lhs == rhs);
}

template<typename T>
inline bool operator<(BasicColor<T> const& lhs, BasicColor<T> const& rhs)
{
    auto tie =
        [](BasicColor<T> const& obj) {
            return std::tie(
                obj.r,
                obj.g,
                obj.b,
                obj.a);
        };
    return tie(lhs) < tie(rhs);
}

template<typename T>
struct Color
    : public detail::BasicColor<T>
{
    using BasicColor<T>::BasicColor;

    Color() = default;
};

template<>
struct Color<float>
    : public detail::BasicColor<float>
{
    using BasicColor::BasicColor;

    Color() = default;

    Color(Color<uint8_t> const& other);

    Color<float>& operator=(Color<uint8_t> const& other);

    static Color<float> const TransparentBlack;
    static Color<float> const TransparentWhite;
    static Color<float> const AliceBlue;
    static Color<float> const AntiqueWhite;
    static Color<float> const Aqua;
    static Color<float> const Aquamarine;
    static Color<float> const Azure;
    static Color<float> const Beige;
    static Color<float> const Bisque;
    static Color<float> const Black;
    static Color<float> const BlanchedAlmond;
    static Color<float> const Blue;
    static Color<float> const BlueViolet;
    static Color<float> const Brown;
    static Color<float> const BurlyWood;
    static Color<float> const CadetBlue;
    static Color<float> const Chartreuse;
    static Color<float> const Chocolate;
    static Color<float> const Coral;
    static Color<float> const CornflowerBlue;
    static Color<float> const Cornsilk;
    static Color<float> const Crimson;
    static Color<float> const Cyan;
    static Color<float> const DarkBlue;
    static Color<float> const DarkCyan;
    static Color<float> const DarkGoldenrod;
    static Color<float> const DarkGray;
    static Color<float> const DarkGreen;
    static Color<float> const DarkKhaki;
    static Color<float> const DarkMagenta;
    static Color<float> const DarkOliveGreen;
    static Color<float> const DarkOrange;
    static Color<float> const DarkOrchid;
    static Color<float> const DarkRed;
    static Color<float> const DarkSalmon;
    static Color<float> const DarkSeaGreen;
    static Color<float> const DarkSlateBlue;
    static Color<float> const DarkSlateGray;
    static Color<float> const DarkTurquoise;
    static Color<float> const DarkViolet;
    static Color<float> const DeepPink;
    static Color<float> const DeepSkyBlue;
    static Color<float> const DimGray;
    static Color<float> const DodgerBlue;
    static Color<float> const Firebrick;
    static Color<float> const FloralWhite;
    static Color<float> const ForestGreen;
    static Color<float> const Fuchsia;
    static Color<float> const Gainsboro;
    static Color<float> const GhostWhite;
    static Color<float> const Gold;
    static Color<float> const Goldenrod;
    static Color<float> const Gray;
    static Color<float> const Green;
    static Color<float> const GreenYellow;
    static Color<float> const Honeydew;
    static Color<float> const HotPink;
    static Color<float> const IndianRed;
    static Color<float> const Indigo;
    static Color<float> const Ivory;
    static Color<float> const Khaki;
    static Color<float> const Lavender;
    static Color<float> const LavenderBlush;
    static Color<float> const LawnGreen;
    static Color<float> const LemonChiffon;
    static Color<float> const LightBlue;
    static Color<float> const LightCoral;
    static Color<float> const LightCyan;
    static Color<float> const LightGoldenrodYellow;
    static Color<float> const LightGreen;
    static Color<float> const LightGray;
    static Color<float> const LightPink;
    static Color<float> const LightSalmon;
    static Color<float> const LightSeaGreen;
    static Color<float> const LightSkyBlue;
    static Color<float> const LightSlateGray;
    static Color<float> const LightSteelBlue;
    static Color<float> const LightYellow;
    static Color<float> const Lime;
    static Color<float> const LimeGreen;
    static Color<float> const Linen;
    static Color<float> const Magenta;
    static Color<float> const Maroon;
    static Color<float> const MediumAquamarine;
    static Color<float> const MediumBlue;
    static Color<float> const MediumOrchid;
    static Color<float> const MediumPurple;
    static Color<float> const MediumSeaGreen;
    static Color<float> const MediumSlateBlue;
    static Color<float> const MediumSpringGreen;
    static Color<float> const MediumTurquoise;
    static Color<float> const MediumVioletRed;
    static Color<float> const MidnightBlue;
    static Color<float> const MintCream;
    static Color<float> const MistyRose;
    static Color<float> const Moccasin;
    static Color<float> const NavajoWhite;
    static Color<float> const Navy;
    static Color<float> const OldLace;
    static Color<float> const Olive;
    static Color<float> const OliveDrab;
    static Color<float> const Orange;
    static Color<float> const OrangeRed;
    static Color<float> const Orchid;
    static Color<float> const PaleGoldenrod;
    static Color<float> const PaleGreen;
    static Color<float> const PaleTurquoise;
    static Color<float> const PaleVioletRed;
    static Color<float> const PapayaWhip;
    static Color<float> const PeachPuff;
    static Color<float> const Peru;
    static Color<float> const Pink;
    static Color<float> const Plum;
    static Color<float> const PowderBlue;
    static Color<float> const Purple;
    static Color<float> const Red;
    static Color<float> const RosyBrown;
    static Color<float> const RoyalBlue;
    static Color<float> const SaddleBrown;
    static Color<float> const Salmon;
    static Color<float> const SandyBrown;
    static Color<float> const SeaGreen;
    static Color<float> const SeaShell;
    static Color<float> const Sienna;
    static Color<float> const Silver;
    static Color<float> const SkyBlue;
    static Color<float> const SlateBlue;
    static Color<float> const SlateGray;
    static Color<float> const Snow;
    static Color<float> const SpringGreen;
    static Color<float> const SteelBlue;
    static Color<float> const Tan;
    static Color<float> const Teal;
    static Color<float> const Thistle;
    static Color<float> const Tomato;
    static Color<float> const Turquoise;
    static Color<float> const Violet;
    static Color<float> const Wheat;
    static Color<float> const White;
    static Color<float> const WhiteSmoke;
    static Color<float> const Yellow;
    static Color<float> const YellowGreen;
};

template<>
struct Color<uint8_t>
    : public detail::BasicColor<uint8_t>
{
    using BasicColor::BasicColor;

    Color() = default;

    Color(Color<float> const& other);

    Color<uint8_t>& operator=(Color<float> const& other);

    static Color<uint8_t> const TransparentBlack;
    static Color<uint8_t> const TransparentWhite;
    static Color<uint8_t> const AliceBlue;
    static Color<uint8_t> const AntiqueWhite;
    static Color<uint8_t> const Aqua;
    static Color<uint8_t> const Aquamarine;
    static Color<uint8_t> const Azure;
    static Color<uint8_t> const Beige;
    static Color<uint8_t> const Bisque;
    static Color<uint8_t> const Black;
    static Color<uint8_t> const BlanchedAlmond;
    static Color<uint8_t> const Blue;
    static Color<uint8_t> const BlueViolet;
    static Color<uint8_t> const Brown;
    static Color<uint8_t> const BurlyWood;
    static Color<uint8_t> const CadetBlue;
    static Color<uint8_t> const Chartreuse;
    static Color<uint8_t> const Chocolate;
    static Color<uint8_t> const Coral;
    static Color<uint8_t> const CornflowerBlue;
    static Color<uint8_t> const Cornsilk;
    static Color<uint8_t> const Crimson;
    static Color<uint8_t> const Cyan;
    static Color<uint8_t> const DarkBlue;
    static Color<uint8_t> const DarkCyan;
    static Color<uint8_t> const DarkGoldenrod;
    static Color<uint8_t> const DarkGray;
    static Color<uint8_t> const DarkGreen;
    static Color<uint8_t> const DarkKhaki;
    static Color<uint8_t> const DarkMagenta;
    static Color<uint8_t> const DarkOliveGreen;
    static Color<uint8_t> const DarkOrange;
    static Color<uint8_t> const DarkOrchid;
    static Color<uint8_t> const DarkRed;
    static Color<uint8_t> const DarkSalmon;
    static Color<uint8_t> const DarkSeaGreen;
    static Color<uint8_t> const DarkSlateBlue;
    static Color<uint8_t> const DarkSlateGray;
    static Color<uint8_t> const DarkTurquoise;
    static Color<uint8_t> const DarkViolet;
    static Color<uint8_t> const DeepPink;
    static Color<uint8_t> const DeepSkyBlue;
    static Color<uint8_t> const DimGray;
    static Color<uint8_t> const DodgerBlue;
    static Color<uint8_t> const Firebrick;
    static Color<uint8_t> const FloralWhite;
    static Color<uint8_t> const ForestGreen;
    static Color<uint8_t> const Fuchsia;
    static Color<uint8_t> const Gainsboro;
    static Color<uint8_t> const GhostWhite;
    static Color<uint8_t> const Gold;
    static Color<uint8_t> const Goldenrod;
    static Color<uint8_t> const Gray;
    static Color<uint8_t> const Green;
    static Color<uint8_t> const GreenYellow;
    static Color<uint8_t> const Honeydew;
    static Color<uint8_t> const HotPink;
    static Color<uint8_t> const IndianRed;
    static Color<uint8_t> const Indigo;
    static Color<uint8_t> const Ivory;
    static Color<uint8_t> const Khaki;
    static Color<uint8_t> const Lavender;
    static Color<uint8_t> const LavenderBlush;
    static Color<uint8_t> const LawnGreen;
    static Color<uint8_t> const LemonChiffon;
    static Color<uint8_t> const LightBlue;
    static Color<uint8_t> const LightCoral;
    static Color<uint8_t> const LightCyan;
    static Color<uint8_t> const LightGoldenrodYellow;
    static Color<uint8_t> const LightGreen;
    static Color<uint8_t> const LightGray;
    static Color<uint8_t> const LightPink;
    static Color<uint8_t> const LightSalmon;
    static Color<uint8_t> const LightSeaGreen;
    static Color<uint8_t> const LightSkyBlue;
    static Color<uint8_t> const LightSlateGray;
    static Color<uint8_t> const LightSteelBlue;
    static Color<uint8_t> const LightYellow;
    static Color<uint8_t> const Lime;
    static Color<uint8_t> const LimeGreen;
    static Color<uint8_t> const Linen;
    static Color<uint8_t> const Magenta;
    static Color<uint8_t> const Maroon;
    static Color<uint8_t> const MediumAquamarine;
    static Color<uint8_t> const MediumBlue;
    static Color<uint8_t> const MediumOrchid;
    static Color<uint8_t> const MediumPurple;
    static Color<uint8_t> const MediumSeaGreen;
    static Color<uint8_t> const MediumSlateBlue;
    static Color<uint8_t> const MediumSpringGreen;
    static Color<uint8_t> const MediumTurquoise;
    static Color<uint8_t> const MediumVioletRed;
    static Color<uint8_t> const MidnightBlue;
    static Color<uint8_t> const MintCream;
    static Color<uint8_t> const MistyRose;
    static Color<uint8_t> const Moccasin;
    static Color<uint8_t> const NavajoWhite;
    static Color<uint8_t> const Navy;
    static Color<uint8_t> const OldLace;
    static Color<uint8_t> const Olive;
    static Color<uint8_t> const OliveDrab;
    static Color<uint8_t> const Orange;
    static Color<uint8_t> const OrangeRed;
    static Color<uint8_t> const Orchid;
    static Color<uint8_t> const PaleGoldenrod;
    static Color<uint8_t> const PaleGreen;
    static Color<uint8_t> const PaleTurquoise;
    static Color<uint8_t> const PaleVioletRed;
    static Color<uint8_t> const PapayaWhip;
    static Color<uint8_t> const PeachPuff;
    static Color<uint8_t> const Peru;
    static Color<uint8_t> const Pink;
    static Color<uint8_t> const Plum;
    static Color<uint8_t> const PowderBlue;
    static Color<uint8_t> const Purple;
    static Color<uint8_t> const Red;
    static Color<uint8_t> const RosyBrown;
    static Color<uint8_t> const RoyalBlue;
    static Color<uint8_t> const SaddleBrown;
    static Color<uint8_t> const Salmon;
    static Color<uint8_t> const SandyBrown;
    static Color<uint8_t> const SeaGreen;
    static Color<uint8_t> const SeaShell;
    static Color<uint8_t> const Sienna;
    static Color<uint8_t> const Silver;
    static Color<uint8_t> const SkyBlue;
    static Color<uint8_t> const SlateBlue;
    static Color<uint8_t> const SlateGray;
    static Color<uint8_t> const Snow;
    static Color<uint8_t> const SpringGreen;
    static Color<uint8_t> const SteelBlue;
    static Color<uint8_t> const Tan;
    static Color<uint8_t> const Teal;
    static Color<uint8_t> const Thistle;
    static Color<uint8_t> const Tomato;
    static Color<uint8_t> const Turquoise;
    static Color<uint8_t> const Violet;
    static Color<uint8_t> const Wheat;
    static Color<uint8_t> const White;
    static Color<uint8_t> const WhiteSmoke;
    static Color<uint8_t> const Yellow;
    static Color<uint8_t> const YellowGreen;
};

}  // namespace detail

using Color = detail::Color<float>;

using Color32 = detail::Color<uint8_t>;

}  // namespace api_types
}  // namespace gpa