colour.h

[詳解]

/*
 * Copyright 2001-2021 oZ/acy (名賀月晃嗣)
 * Redistribution and use in source and binary forms, 
 *     with or without modification, 
 *   are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#ifndef INCLUDE_GUARD_EUNOMIA_COLOUR_H
#define INCLUDE_GUARD_EUNOMIA_COLOUR_H
 
#include <algorithm>
#include <cstdint>
 
namespace eunomia
{
class RgbColour
{
public:
  std::uint8_t red;   
  std::uint8_t green; 
  std::uint8_t blue;  
 
public:
  constexpr RgbColour() noexcept : red(0), green(0), blue(0) {}
 
  constexpr 
  RgbColour(std::uint8_t r, std::uint8_t g, std::uint8_t b) noexcept
    : red(r), green(g), blue(b)
    {}
 
  constexpr
  bool operator==(const RgbColour& other) const noexcept
    { return red == other.red && green == other.green && blue == other.blue; }
 
  constexpr
  bool operator!=(const RgbColour& other) const noexcept
    { return !(*this == other); }
};
 
 
class RgbaColour
{
public:
  std::uint8_t red;   
  std::uint8_t green; 
  std::uint8_t blue;  
  std::uint8_t alpha; 
 
public:
  constexpr RgbaColour() noexcept : red(0), green(0), blue(0), alpha(255) {}
 
  constexpr
  RgbaColour(
    std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t a) noexcept
    : red(r), green(g), blue(b), alpha(a)
    {}
 
  explicit constexpr RgbaColour(const RgbColour& rgb) noexcept
    : red(rgb.red), green(rgb.green), blue(rgb.blue), alpha(255)
    {}
 
  explicit operator RgbColour() const noexcept
    { return RgbColour(red, green, blue); }
 
  constexpr
  bool operator==(const RgbaColour& other) const noexcept
  {
    return
      red == other.red && green == other.green
      && blue == other.blue && alpha == other.alpha;
  }
 
  constexpr
  bool operator!=(const RgbaColour& other) const noexcept
    { return !(*this == other); }
};
 
 
 
 
 
constexpr
inline
bool operator==(const RgbaColour& x, const RgbColour& y) noexcept
  { return x.red == y.red && x.green == y.green && x.blue == y.blue; }
 
constexpr
inline
bool operator!=(const RgbaColour& x, const RgbColour& y) noexcept
  { return !(x == y); }
 
constexpr
inline
bool operator==(const RgbColour& x, const RgbaColour& y) noexcept
  { return y == x; }
 
constexpr
inline
bool operator!=(const RgbColour& x, const RgbaColour& y) noexcept
  { return !(x == y); }
 
 
 
 
 
class NormalBrendCopier
{
public:
  void operator()(const RgbaColour& src, RgbColour& dst) noexcept
  {
    dst.red = src.red;
    dst.green = src.green;
    dst.blue = src.blue;
  }
 
  void operator()(const RgbColour& src, RgbaColour& dst) noexcept
  {
    dst.red = src.red;
    dst.green = src.green;
    dst.blue = src.blue;
    // dst.alphaは變更しない
  }
};
 
 
class AddBrendCopier
{
public:
  void operator()(const RgbColour& src, RgbColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red + src.red, 0, 255);
    dst.green = std::clamp(dst.green + src.green, 0, 255);
    dst.red = std::clamp(dst.blue + src.blue, 0, 255);
  }
 
  void operator()(const RgbaColour& src, RgbColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red + src.red, 0, 255);
    dst.green = std::clamp(dst.green + src.green, 0, 255);
    dst.red = std::clamp(dst.blue + src.blue, 0, 255);
  }
 
  void operator()(const RgbColour& src, RgbaColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red + src.red, 0, 255);
    dst.green = std::clamp(dst.green + src.green, 0, 255);
    dst.red = std::clamp(dst.blue + src.blue, 0, 255);
    // dst.alphaは變更しない
  }
 
  void operator()(const RgbaColour& src, RgbaColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red + src.red, 0, 255);
    dst.green = std::clamp(dst.green + src.green, 0, 255);
    dst.red = std::clamp(dst.blue + src.blue, 0, 255);
    // dst.alphaは變更しない
  }
};
 
 
class MulBrendCopier
{
public:
  void operator()(const RgbColour& src, RgbColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red * src.red / 255, 0, 255);
    dst.green = std::clamp(dst.green * src.green / 255, 0, 255);
    dst.blue = std::clamp(dst.blue * src.blue / 255, 0, 255);
  }
 
  void operator()(const RgbaColour& src, RgbColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red * src.red / 255, 0, 255);
    dst.green = std::clamp(dst.green * src.green / 255, 0, 255);
    dst.blue = std::clamp(dst.blue * src.blue / 255, 0, 255);
  }
 
  void operator()(const RgbColour& src, RgbaColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red * src.red / 255, 0, 255);
    dst.green = std::clamp(dst.green * src.green / 255, 0, 255);
    dst.blue = std::clamp(dst.blue * src.blue / 255, 0, 255);
    // dst.alphaは變更しない
  }
 
  void operator()(const RgbaColour& src, RgbaColour& dst) noexcept
  {
    dst.red = std::clamp(dst.red * src.red / 255, 0, 255);
    dst.green = std::clamp(dst.green * src.green / 255, 0, 255);
    dst.blue = std::clamp(dst.blue * src.blue / 255, 0, 255);
    // dst.alphaは變更しない
  }
};
 
 
class AlphaBrendCopier
{
public:
  void operator()(const RgbaColour& src, RgbColour& dst) noexcept
  {
    dst.red
      = std::clamp(
          src.red * src.alpha / 255 + dst.red * (255 - src.alpha) / 255,
          0, 255);
    dst.green
      = std::clamp(
          src.green * src.alpha / 255 + dst.green * (255 - src.alpha) / 255,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * src.alpha / 255 + dst.blue * (255 - src.alpha) / 255,
          0, 255);
  }
 
  void operator()(const RgbaColour& src, RgbaColour& dst) noexcept
  {
    dst.red
      = std::clamp(
          src.red * src.alpha / 255 + dst.red * (255 - src.alpha) / 255,
          0, 255);
    dst.green
      = std::clamp(
          src.green * src.alpha / 255 + dst.green * (255 - src.alpha) / 255,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * src.alpha / 255 + dst.blue * (255 - src.alpha) / 255,
          0, 255);
    dst.alpha
      = std::clamp(
          src.alpha + dst.alpha * (255 - src.alpha) / 255,
          0, 255);
  }
};
 
 
class CopierUsingFixedAlpha
{
private:
  std::uint8_t alpha_;
 
public:
  explicit CopierUsingFixedAlpha(std::uint8_t a) noexcept : alpha_(a) {}
 
  void operator()(const RgbColour& src, RgbColour& dst) const noexcept
  {
    dst.red
      = std::clamp(
          src.red * alpha_ / 255 + dst.red * (255 - alpha_) / 255,
          0, 255);
    dst.green
      = std::clamp(
          src.green * alpha_ / 255 + dst.green * (255 - alpha_) / 255,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * alpha_ / 255 + dst.blue * (255 - alpha_) / 255,
          0, 255);
  }
 
  void operator()(const RgbaColour& src, RgbColour& dst) const noexcept
  {
    // srcのアルファ値を、固定アルファ値alpha_で乘じた上で用ゐる。
    int a = alpha_ * src.alpha;
    dst.red
      = std::clamp(
          src.red * a / 65025 + dst.red * (65025 - a) / 65025,
          0, 255);
    dst.green
      = std::clamp(
          src.green * a / 65025 + dst.green * (65025 - a) / 65025,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * a / 65025 + dst.blue * (65025 - a) / 65025,
          0, 255);
  }
 
  void operator()(const RgbColour& src, RgbaColour& dst) const noexcept
  {
    dst.red
      = std::clamp(
          src.red * alpha_ / 255 + dst.red * (255 - alpha_) / 255,
          0, 255);
    dst.green
      = std::clamp(
          src.green * alpha_ / 255 + dst.green * (255 - alpha_) / 255,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * alpha_ / 255 + dst.blue * (255 - alpha_) / 255,
          0, 255);
    dst.alpha
      = std::clamp(
          alpha_ + dst.alpha * (255 - alpha_) / 255,
          0, 255);
  }
 
  void operator()(const RgbaColour& src, RgbaColour& dst) const noexcept
  {
    // srcのアルファ値を、固定アルファ値alpha_で乘じた上で用ゐる。
    int a = alpha_ * src.alpha;
    dst.red
      = std::clamp(
          src.red * a / 65025 + dst.red * (65025 - a) / 65025,
          0, 255);
    dst.green
      = std::clamp(
          src.green * a / 65025 + dst.green * (65025 - a) / 65025,
          0, 255);
    dst.blue
      = std::clamp(
          src.blue * a / 65025 + dst.blue * (65025 - a) / 65025,
          0, 255);
 
    dst.alpha
      = std::clamp(
          a / 255 + dst.alpha * (65025 - a) / 65025,
          0, 255);
  }
};
 
 
}//end of namespace eunomia
 
 
 
 
#endif // INCLUDE_GUARD_EUNOMIA_COLOUR_H