color_mode.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include "esphome/core/finite_set_mask.h"
#include "esphome/core/hal.h"
 
namespace esphome::light {
 
enum class ColorCapability : uint8_t {
  ON_OFF = 1 << 0,
  BRIGHTNESS = 1 << 1,
  WHITE = 1 << 2,
  COLOR_TEMPERATURE = 1 << 3,
  COLD_WARM_WHITE = 1 << 4,
  RGB = 1 << 5
};
 
class ColorCapabilityHelper {
 public:
  constexpr ColorCapabilityHelper(ColorCapability val) : val_(val) {}
  constexpr operator ColorCapability() const { return val_; }
  constexpr operator uint8_t() const { return static_cast<uint8_t>(val_); }
  constexpr operator bool() const { return static_cast<uint8_t>(val_) != 0; }
 
 protected:
  ColorCapability val_;
};
constexpr ColorCapabilityHelper operator&(ColorCapability lhs, ColorCapability rhs) {
  return static_cast<ColorCapability>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
}
constexpr ColorCapabilityHelper operator&(ColorCapabilityHelper lhs, ColorCapability rhs) {
  return static_cast<ColorCapability>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
}
constexpr ColorCapabilityHelper operator|(ColorCapability lhs, ColorCapability rhs) {
  return static_cast<ColorCapability>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
constexpr ColorCapabilityHelper operator|(ColorCapabilityHelper lhs, ColorCapability rhs) {
  return static_cast<ColorCapability>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
 
enum class ColorMode : uint8_t {
  UNKNOWN = 0,
  ON_OFF = (uint8_t) ColorCapability::ON_OFF,
  BRIGHTNESS = (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS),
  WHITE = (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::WHITE),
  COLOR_TEMPERATURE =
      (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::COLOR_TEMPERATURE),
  COLD_WARM_WHITE =
      (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::COLD_WARM_WHITE),
  RGB = (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::RGB),
  RGB_WHITE =
      (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::RGB | ColorCapability::WHITE),
  RGB_COLOR_TEMPERATURE = (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::RGB |
                                     ColorCapability::WHITE | ColorCapability::COLOR_TEMPERATURE),
  RGB_COLD_WARM_WHITE = (uint8_t) (ColorCapability::ON_OFF | ColorCapability::BRIGHTNESS | ColorCapability::RGB |
                                   ColorCapability::COLD_WARM_WHITE),
};
 
class ColorModeHelper {
 public:
  constexpr ColorModeHelper(ColorMode val) : val_(val) {}
  constexpr operator ColorMode() const { return val_; }
  constexpr operator uint8_t() const { return static_cast<uint8_t>(val_); }
  constexpr operator bool() const { return static_cast<uint8_t>(val_) != 0; }
 
 protected:
  ColorMode val_;
};
constexpr ColorModeHelper operator&(ColorMode lhs, ColorMode rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
}
constexpr ColorModeHelper operator&(ColorMode lhs, ColorCapability rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
}
constexpr ColorModeHelper operator&(ColorModeHelper lhs, ColorMode rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
}
constexpr ColorModeHelper operator|(ColorMode lhs, ColorMode rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
constexpr ColorModeHelper operator|(ColorMode lhs, ColorCapability rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
constexpr ColorModeHelper operator|(ColorModeHelper lhs, ColorMode rhs) {
  return static_cast<ColorMode>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
 
// Type alias for raw color mode bitmask values
using color_mode_bitmask_t = uint16_t;
 
// Lookup table for ColorMode bit mapping
// This array defines the canonical order of color modes (bit 0-9). One shared copy in flash; read it at run time
// through color_mode_at().
inline constexpr ColorMode COLOR_MODE_LOOKUP[] PROGMEM = {
    ColorMode::UNKNOWN,                // bit 0
    ColorMode::ON_OFF,                 // bit 1
    ColorMode::BRIGHTNESS,             // bit 2
    ColorMode::WHITE,                  // bit 3
    ColorMode::COLOR_TEMPERATURE,      // bit 4
    ColorMode::COLD_WARM_WHITE,        // bit 5
    ColorMode::RGB,                    // bit 6
    ColorMode::RGB_WHITE,              // bit 7
    ColorMode::RGB_COLOR_TEMPERATURE,  // bit 8
    ColorMode::RGB_COLD_WARM_WHITE,    // bit 9
};
 
constexpr ColorMode color_mode_at(unsigned bit) {
  if (__builtin_is_constant_evaluated())
    return COLOR_MODE_LOOKUP[bit];
  return static_cast<ColorMode>(progmem_read_byte(reinterpret_cast<const uint8_t *>(&COLOR_MODE_LOOKUP[bit])));
}
 
struct ColorModeBitPolicy {
  using mask_t = uint16_t;  // 10 bits requires uint16_t
  static constexpr int MAX_BITS = sizeof(COLOR_MODE_LOOKUP) / sizeof(COLOR_MODE_LOOKUP[0]);
 
  static constexpr unsigned to_bit(ColorMode mode) {
    for (int i = 0; i < MAX_BITS; ++i) {
      if (color_mode_at(i) == mode)
        return i;
    }
    return 0;
  }
 
  static constexpr ColorMode from_bit(unsigned bit) {
    return (bit < MAX_BITS) ? color_mode_at(bit) : ColorMode::UNKNOWN;
  }
};
 
// Type alias for ColorMode bitmask using policy-based design
using ColorModeMask = FiniteSetMask<ColorMode, ColorModeBitPolicy>;
 
// Number of ColorCapability enum values
constexpr int COLOR_CAPABILITY_COUNT = 6;
 
constexpr uint16_t compute_capability_bitmask(ColorCapability capability) {
  uint16_t mask = 0;
  uint8_t cap_bit = static_cast<uint8_t>(capability);
 
  // Check each ColorMode to see if it has this capability
  constexpr int color_mode_count = sizeof(COLOR_MODE_LOOKUP) / sizeof(COLOR_MODE_LOOKUP[0]);
  for (int bit = 0; bit < color_mode_count; ++bit) {
    uint8_t mode_val = static_cast<uint8_t>(color_mode_at(bit));
    if ((mode_val & cap_bit) != 0) {
      mask |= (1 << bit);
    }
  }
  return mask;
}
 
constexpr uint16_t CAPABILITY_BITMASKS[] = {
    compute_capability_bitmask(ColorCapability::ON_OFF),             // 1 << 0
    compute_capability_bitmask(ColorCapability::BRIGHTNESS),         // 1 << 1
    compute_capability_bitmask(ColorCapability::WHITE),              // 1 << 2
    compute_capability_bitmask(ColorCapability::COLOR_TEMPERATURE),  // 1 << 3
    compute_capability_bitmask(ColorCapability::COLD_WARM_WHITE),    // 1 << 4
    compute_capability_bitmask(ColorCapability::RGB),                // 1 << 5
};
 
inline int capability_to_index(ColorCapability capability) {
  uint8_t cap_val = static_cast<uint8_t>(capability);
#if defined(__GNUC__) || defined(__clang__)
  // Use compiler intrinsic for efficient bit position lookup (O(1) vs O(log n))
  return __builtin_ctz(cap_val);
#else
  // Fallback for compilers without __builtin_ctz
  int index = 0;
  while (cap_val > 1) {
    cap_val >>= 1;
    ++index;
  }
  return index;
#endif
}
 
inline bool has_capability(const ColorModeMask &mask, ColorCapability capability) {
  // Lookup the pre-computed bitmask for this capability and check intersection with our mask
  return (mask.get_mask() & CAPABILITY_BITMASKS[capability_to_index(capability)]) != 0;
}
 
}  // namespace esphome::light