color.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#ifndef LIBSBX_MATH_COLOR_HPP_
#define LIBSBX_MATH_COLOR_HPP_
 
#include <cmath>
 
#include <yaml-cpp/yaml.h>
 
#include <libsbx/utility/hash.hpp>
 
namespace sbx::math {
 
class color {
 
public:
 
  color() noexcept;
 
  color(std::uint32_t rgba) noexcept;
 
  color(std::uint8_t red, std::uint8_t green, std::uint8_t blue, std::uint8_t alpha = 255u) noexcept;
 
  template<std::floating_point Type>
  color(Type red, Type green, Type blue, Type alpha = Type{1}) noexcept;
 
  static auto black() noexcept -> color;
 
  static auto white() noexcept -> color;
 
  static auto red() noexcept -> color;
 
  static auto green() noexcept -> color;
 
  static auto blue() noexcept -> color;
 
  static auto magenta() noexcept -> color;
 
  static auto yellow() noexcept -> color;
 
  static auto cyan() noexcept -> color;
 
  static auto orange() noexcept -> color;
 
  auto r() const noexcept -> const std::float_t&;
 
  auto r() noexcept -> std::float_t&;
 
  auto g() const noexcept -> const std::float_t&;
 
  auto g() noexcept -> std::float_t&;
 
  auto b() const noexcept -> const std::float_t&;
 
  auto b() noexcept -> std::float_t&;
 
  auto a() const noexcept -> const std::float_t&;
 
  auto a() noexcept -> std::float_t&;
 
private:
 
  std::float_t _red;
  std::float_t _green;
  std::float_t _blue;
  std::float_t _alpha;
 
}; // class color
 
auto operator==(const color& lhs, const color& rhs) noexcept -> bool;
 
auto operator*(color lhs, const std::float_t value) -> color;
 
template<std::floating_point Type>
color::color(Type red, Type green, Type blue, Type alpha) noexcept
: _red{static_cast<std::float_t>(red)},
  _green{static_cast<std::float_t>(green)},
  _blue{static_cast<std::float_t>(blue)},
  _alpha{static_cast<std::float_t>(alpha)} { }
 
} // namespace sbx::math
 
template<>
struct YAML::convert<sbx::math::color> {
 
  static auto encode(const sbx::math::color& color) -> Node;
  static auto decode(const Node& node, sbx::math::color& color) -> bool;
 
}; // struct YAML::convert
 
auto operator<<(YAML::Emitter& out, const sbx::math::color& color) -> YAML::Emitter&;
 
template<>
struct std::hash<sbx::math::color> {
 
  auto operator()(const sbx::math::color& color) const noexcept -> std::size_t;
 
}; // struct std::hash
 
#endif // LIBSBX_MATH_COLOR_HPP_