ImathColor.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// 3-channel and 4-channel color representations
//
 
#ifndef INCLUDED_ATOMSMATHCOLOR_H
#define INCLUDED_ATOMSMATHCOLOR_H
 
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
#include <AtomsMath/half.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class T> class Color3 : public Vec3<T>
{
  public:
 
 
    ATOMSMATH_HOSTDEVICE Color3() noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr explicit Color3 (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 (T a, T b, T c) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 (const Color3& c) noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE constexpr Color3 (const Vec3<S>& v) noexcept;
 
    ~Color3() = default;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator= (const Color3& c) noexcept;
 
    
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator+= (const Color3& c) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator+ (const Color3& c) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator-= (const Color3& c) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator- (const Color3& c) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator-() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& negate() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator*= (const Color3& c) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator*= (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator* (const Color3& c) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator* (T a) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator/= (const Color3& c) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color3& operator/= (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator/ (const Color3& c) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color3 operator/ (T a) const noexcept;
 
};
 
 
template <class T> class Color4
{
  public:
 
 
    T r, g, b, a;
 
 
 
    ATOMSMATH_HOSTDEVICE Color4() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 explicit Color4 (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Color4 (T a, T b, T c, T d) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Color4 (const Color4& v) noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Color4 (const Color4<S>& v) noexcept;
 
    ~Color4() = default;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator= (const Color4& v) noexcept;
 
    ATOMSMATH_HOSTDEVICE T& operator[] (int i) noexcept;
 
    ATOMSMATH_HOSTDEVICE const T& operator[] (int i) const noexcept;
 
    
    
    template <class S> ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Color4<S>& v) const noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Color4<S>& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator+= (const Color4& v) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator+ (const Color4& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator-= (const Color4& v) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator- (const Color4& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator-() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& negate() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator*= (const Color4& v) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator*= (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator* (const Color4& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator* (T a) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator/= (const Color4& v) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 const Color4& operator/= (T a) noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator/ (const Color4& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Color4 operator/ (T a) const noexcept;
 
 
    
    ATOMSMATH_HOSTDEVICE constexpr static unsigned int dimensions() noexcept { return 4; }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeLowest() noexcept { return std::numeric_limits<T>::lowest(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeMax() noexcept { return std::numeric_limits<T>::max(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeSmallest() noexcept { return std::numeric_limits<T>::min(); }
 
    ATOMSMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() noexcept { return std::numeric_limits<T>::epsilon(); }
 
    
    typedef T BaseType;
 
 
    template <class S> ATOMSMATH_HOSTDEVICE void setValue (S a, S b, S c, S d) noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE void setValue (const Color4<S>& v) noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE void getValue (S& a, S& b, S& c, S& d) const noexcept;
 
    template <class S> ATOMSMATH_HOSTDEVICE void getValue (Color4<S>& v) const noexcept;
 
    ATOMSMATH_HOSTDEVICE T* getValue() noexcept;
 
    ATOMSMATH_HOSTDEVICE const T* getValue() const noexcept;
 
};
 
template <class T> std::ostream& operator<< (std::ostream& s, const Color4<T>& v);
 
template <class S, class T> constexpr Color4<T> operator* (S a, const Color4<T>& v) noexcept;
 
typedef Color3<float> Color3f;
 
typedef Color3<half> Color3h;
 
typedef Color3<unsigned char> Color3c;
 
typedef Color3<half> C3h;
 
typedef Color3<float> C3f;
 
typedef Color3<unsigned char> C3c;
 
typedef Color4<float> Color4f;
 
typedef Color4<half> Color4h;
 
typedef Color4<unsigned char> Color4c;
 
typedef Color4<float> C4f;
 
typedef Color4<half> C4h;
 
typedef Color4<unsigned char> C4c;
 
typedef unsigned int PackedColor;
 
//
// Implementation of Color3
//
 
template <class T> inline Color3<T>::Color3() noexcept : Vec3<T>()
{
    // empty
}
 
template <class T> constexpr inline Color3<T>::Color3 (T a) noexcept : Vec3<T> (a)
{
    // empty
}
 
template <class T> constexpr inline Color3<T>::Color3 (T a, T b, T c) noexcept : Vec3<T> (a, b, c)
{
    // empty
}
 
template <class T> constexpr inline Color3<T>::Color3 (const Color3& c) noexcept : Vec3<T> (c)
{
    // empty
}
 
template <class T>
template <class S>
constexpr inline Color3<T>::Color3 (const Vec3<S>& v) noexcept : Vec3<T> (v)
{
    //empty
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator= (const Color3& c) noexcept
{
    *((Vec3<T>*) this) = c;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator+= (const Color3& c) noexcept
{
    *((Vec3<T>*) this) += c;
    return *this;
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator+ (const Color3& c) const noexcept
{
    return Color3 (*(Vec3<T>*) this + (const Vec3<T>&) c);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator-= (const Color3& c) noexcept
{
    *((Vec3<T>*) this) -= c;
    return *this;
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator- (const Color3& c) const noexcept
{
    return Color3 (*(Vec3<T>*) this - (const Vec3<T>&) c);
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator-() const noexcept
{
    return Color3 (-(*(Vec3<T>*) this));
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::negate() noexcept
{
    ((Vec3<T>*) this)->negate();
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator*= (const Color3& c) noexcept
{
    *((Vec3<T>*) this) *= c;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator*= (T a) noexcept
{
    *((Vec3<T>*) this) *= a;
    return *this;
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator* (const Color3& c) const noexcept
{
    return Color3 (*(Vec3<T>*) this * (const Vec3<T>&) c);
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator* (T a) const noexcept
{
    return Color3 (*(Vec3<T>*) this * a);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator/= (const Color3& c) noexcept
{
    *((Vec3<T>*) this) /= c;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color3<T>&
Color3<T>::operator/= (T a) noexcept
{
    *((Vec3<T>*) this) /= a;
    return *this;
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator/ (const Color3& c) const noexcept
{
    return Color3 (*(Vec3<T>*) this / (const Vec3<T>&) c);
}
 
template <class T>
constexpr inline Color3<T>
Color3<T>::operator/ (T a) const noexcept
{
    return Color3 (*(Vec3<T>*) this / a);
}
 
//
// Implementation of Color4
//
 
template <class T>
inline T&
Color4<T>::operator[] (int i) noexcept
{
    return (&r)[i];
}
 
template <class T>
inline const T&
Color4<T>::operator[] (int i) const noexcept
{
    return (&r)[i];
}
 
template <class T> inline Color4<T>::Color4() noexcept
{
    // empty
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Color4<T>::Color4 (T x) noexcept
{
    r = g = b = a = x;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Color4<T>::Color4 (T x, T y, T z, T w) noexcept
{
    r = x;
    g = y;
    b = z;
    a = w;
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Color4<T>::Color4 (const Color4& v) noexcept
{
    r = v.r;
    g = v.g;
    b = v.b;
    a = v.a;
}
 
template <class T>
template <class S>
ATOMSMATH_CONSTEXPR14 inline Color4<T>::Color4 (const Color4<S>& v) noexcept
{
    r = T (v.r);
    g = T (v.g);
    b = T (v.b);
    a = T (v.a);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator= (const Color4& v) noexcept
{
    r = v.r;
    g = v.g;
    b = v.b;
    a = v.a;
    return *this;
}
 
template <class T>
template <class S>
inline void
Color4<T>::setValue (S x, S y, S z, S w) noexcept
{
    r = T (x);
    g = T (y);
    b = T (z);
    a = T (w);
}
 
template <class T>
template <class S>
inline void
Color4<T>::setValue (const Color4<S>& v) noexcept
{
    r = T (v.r);
    g = T (v.g);
    b = T (v.b);
    a = T (v.a);
}
 
template <class T>
template <class S>
inline void
Color4<T>::getValue (S& x, S& y, S& z, S& w) const noexcept
{
    x = S (r);
    y = S (g);
    z = S (b);
    w = S (a);
}
 
template <class T>
template <class S>
inline void
Color4<T>::getValue (Color4<S>& v) const noexcept
{
    v.r = S (r);
    v.g = S (g);
    v.b = S (b);
    v.a = S (a);
}
 
template <class T>
inline T*
Color4<T>::getValue() noexcept
{
    return (T*) &r;
}
 
template <class T>
inline const T*
Color4<T>::getValue() const noexcept
{
    return (const T*) &r;
}
 
template <class T>
template <class S>
constexpr inline bool
Color4<T>::operator== (const Color4<S>& v) const noexcept
{
    return r == v.r && g == v.g && b == v.b && a == v.a;
}
 
template <class T>
template <class S>
constexpr inline bool
Color4<T>::operator!= (const Color4<S>& v) const noexcept
{
    return r != v.r || g != v.g || b != v.b || a != v.a;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator+= (const Color4& v) noexcept
{
    r += v.r;
    g += v.g;
    b += v.b;
    a += v.a;
    return *this;
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator+ (const Color4& v) const noexcept
{
    return Color4 (r + v.r, g + v.g, b + v.b, a + v.a);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator-= (const Color4& v) noexcept
{
    r -= v.r;
    g -= v.g;
    b -= v.b;
    a -= v.a;
    return *this;
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator- (const Color4& v) const noexcept
{
    return Color4 (r - v.r, g - v.g, b - v.b, a - v.a);
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator-() const noexcept
{
    return Color4 (-r, -g, -b, -a);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::negate() noexcept
{
    r = -r;
    g = -g;
    b = -b;
    a = -a;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator*= (const Color4& v) noexcept
{
    r *= v.r;
    g *= v.g;
    b *= v.b;
    a *= v.a;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator*= (T x) noexcept
{
    r *= x;
    g *= x;
    b *= x;
    a *= x;
    return *this;
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator* (const Color4& v) const noexcept
{
    return Color4 (r * v.r, g * v.g, b * v.b, a * v.a);
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator* (T x) const noexcept
{
    return Color4 (r * x, g * x, b * x, a * x);
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator/= (const Color4& v) noexcept
{
    r /= v.r;
    g /= v.g;
    b /= v.b;
    a /= v.a;
    return *this;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline const Color4<T>&
Color4<T>::operator/= (T x) noexcept
{
    r /= x;
    g /= x;
    b /= x;
    a /= x;
    return *this;
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator/ (const Color4& v) const noexcept
{
    return Color4 (r / v.r, g / v.g, b / v.b, a / v.a);
}
 
template <class T>
constexpr inline Color4<T>
Color4<T>::operator/ (T x) const noexcept
{
    return Color4 (r / x, g / x, b / x, a / x);
}
 
template <class T>
std::ostream&
operator<< (std::ostream& s, const Color4<T>& v)
{
    return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')';
}
 
//
// Implementation of reverse multiplication
//
 
template <class S, class T>
constexpr inline Color4<T>
operator* (S x, const Color4<T>& v) noexcept
{
    return Color4<T> (x * v.r, x * v.g, x * v.b, x * v.a);
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHCOLOR_H