utils.hpp

Go to the documentation of this file.

 
#ifndef MODES_COLORS_UTILS_HPP
#define MODES_COLORS_UTILS_HPP
 
#include "src/modes/include/compile.hpp"
 
#include "src/system/ext/scale8.h"
#include "src/system/ext/math8.h"
 
#include <cstdint>
 
//
// Color utilities likely already defined elsewhere
//  (but this time in pure constexpr-able INLINE c++)
//
 
namespace lampda::modes::colors {
 
static constexpr LMBD_INLINE uint32_t fromRGB(uint8_t r, uint8_t g, uint8_t b)
{
  uint32_t rx = r;
  uint32_t gx = g;
  return (rx << 16) | (gx << 8) | b;
}
 
struct ToRGB
{
  constexpr LMBD_INLINE ToRGB(uint32_t color) :
    r {(uint8_t)((color >> 16) & 0xff)},
    g {(uint8_t)((color >> 8) & 0xff)},
    b {(uint8_t)(color & 0xff)}
  {
  }
 
  uint8_t r; 
  uint8_t g; 
  uint8_t b; 
};
 
static constexpr LMBD_INLINE uint32_t fromGrey(uint32_t w) { return fromRGB(w, w, w); }
 
static constexpr uint8_t colorRotation[360] = {
        0,   0,   0,   0,   0,   1,   1,   2,   2,   3,   4,   5,   6,   7,   8,   9,   11,  12,  13,  15,  17,  18,
        20,  22,  24,  26,  28,  30,  32,  35,  37,  39,  42,  44,  47,  49,  52,  55,  58,  60,  63,  66,  69,  72,
        75,  78,  81,  85,  88,  91,  94,  97,  101, 104, 107, 111, 114, 117, 121, 124, 127, 131, 134, 137, 141, 144,
        147, 150, 154, 157, 160, 163, 167, 170, 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 202, 205, 208, 210,
        213, 215, 217, 220, 222, 224, 226, 229, 231, 232, 234, 236, 238, 239, 241, 242, 244, 245, 246, 248, 249, 250,
        251, 251, 252, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255, 254, 254, 253, 253, 252, 251, 251, 250,
        249, 248, 246, 245, 244, 242, 241, 239, 238, 236, 234, 232, 231, 229, 226, 224, 222, 220, 217, 215, 213, 210,
        208, 205, 202, 200, 197, 194, 191, 188, 185, 182, 179, 176, 173, 170, 167, 163, 160, 157, 154, 150, 147, 144,
        141, 137, 134, 131, 127, 124, 121, 117, 114, 111, 107, 104, 101, 97,  94,  91,  88,  85,  81,  78,  75,  72,
        69,  66,  63,  60,  58,  55,  52,  49,  47,  44,  42,  39,  37,  35,  32,  30,  28,  26,  24,  22,  20,  18,
        17,  15,  13,  12,  11,  9,   8,   7,   6,   5,   4,   3,   2,   2,   1,   1,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0};
 
static constexpr LMBD_INLINE uint32_t fromAngleHue(uint16_t angleDegrees)
{
  uint8_t r = colorRotation[(angleDegrees + 120) % 360];
  uint8_t g = colorRotation[angleDegrees % 360];
  uint8_t b = colorRotation[(angleDegrees + 240) % 360];
  return fromRGB(r, g, b);
}
 
template<typename UIntTy = uint8_t>
static constexpr uint32_t blend(uint32_t leftColor, uint32_t rightColor, UIntTy blendIndex)
{
  static_assert(std::is_same_v<UIntTy, uint8_t> || std::is_same_v<UIntTy, uint16_t>, "u8 or u16 allowed only");
  constexpr UIntTy blendmax = (std::is_same_v<UIntTy, uint16_t> ? UINT16_MAX : UINT8_MAX);
 
  ToRGB left_rgb(leftColor);
  ToRGB right_rgb(rightColor);
  // left + (right - left) * (blendIndex / maxBlend)
  // Optimized to
  // (left * (maxBlend - blendIndex) + right * blendIndex) / maxBlend
  return fromRGB((static_cast<uint32_t>(left_rgb.r) * (blendmax - blendIndex) +
                  static_cast<uint32_t>(right_rgb.r) * blendIndex) /
                         blendmax,
                 (static_cast<uint32_t>(left_rgb.g) * (blendmax - blendIndex) +
                  static_cast<uint32_t>(right_rgb.g) * blendIndex) /
                         blendmax,
                 (static_cast<uint32_t>(left_rgb.b) * (blendmax - blendIndex) +
                  static_cast<uint32_t>(right_rgb.b) * blendIndex) /
                         blendmax);
}
 
template<bool isVideoMode = false> static uint32_t fade(uint32_t inputColor, uint8_t fadeAmount)
{
  uint32_t res;
  ToRGB input_rgb(inputColor);
 
  if (isVideoMode)
  {
    res = fromRGB(scale8_video(input_rgb.r, fadeAmount),
                  scale8_video(input_rgb.g, fadeAmount),
                  scale8_video(input_rgb.b, fadeAmount));
  }
  else
  {
    res = fromRGB(scale8(input_rgb.r, fadeAmount), scale8(input_rgb.g, fadeAmount), scale8(input_rgb.b, fadeAmount));
  }
  return res;
}
 
template<bool isFast = false> uint32_t add(uint32_t c1, uint32_t c2)
{
  ToRGB input1_rgb(c1);
  ToRGB input2_rgb(c2);
 
  if (isFast)
  {
    return fromRGB(
            qadd8(input1_rgb.r, input2_rgb.r), qadd8(input1_rgb.g, input2_rgb.g), qadd8(input1_rgb.b, input2_rgb.b));
  }
  else
  {
    uint32_t r = input1_rgb.r + input2_rgb.r;
    uint32_t g = input1_rgb.g + input2_rgb.g;
    uint32_t b = input1_rgb.b + input2_rgb.b;
    uint16_t max = r;
    if (g > max)
      max = g;
    if (b > max)
      max = b;
    if (max < 256)
    {
      return fromRGB(r, g, b);
    }
    else
    {
      return fromRGB(r * 255 / max, g * 255 / max, b * 255 / max);
    }
  }
}
 
} // namespace lampda::modes::colors
 
#endif