light_color_values.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/helpers.h"
#include "color_mode.h"
#include <cmath>
 
namespace esphome {
namespace light {
 
inline static uint8_t to_uint8_scale(float x) { return static_cast<uint8_t>(roundf(x * 255.0f)); }
 
class LightColorValues {
 public:
  LightColorValues()
      : state_(0.0f),
        brightness_(1.0f),
        color_brightness_(1.0f),
        red_(1.0f),
        green_(1.0f),
        blue_(1.0f),
        white_(1.0f),
        color_temperature_{0.0f},
        cold_white_{1.0f},
        warm_white_{1.0f},
        color_mode_(ColorMode::UNKNOWN) {}
 
  LightColorValues(ColorMode color_mode, float state, float brightness, float color_brightness, float red, float green,
                   float blue, float white, float color_temperature, float cold_white, float warm_white) {
    this->set_color_mode(color_mode);
    this->set_state(state);
    this->set_brightness(brightness);
    this->set_color_brightness(color_brightness);
    this->set_red(red);
    this->set_green(green);
    this->set_blue(blue);
    this->set_white(white);
    this->set_color_temperature(color_temperature);
    this->set_cold_white(cold_white);
    this->set_warm_white(warm_white);
  }
 
  static LightColorValues lerp(const LightColorValues &start, const LightColorValues &end, float completion) {
    // Directly interpolate the raw values to avoid getter/setter overhead.
    // This is safe because:
    // - All LightColorValues have their values clamped when set via the setters
    // - std::lerp guarantees output is in the same range as inputs
    // - Therefore the output doesn't need clamping, so we can skip the setters
    LightColorValues v;
    v.color_mode_ = end.color_mode_;
    v.state_ = std::lerp(start.state_, end.state_, completion);
    v.brightness_ = std::lerp(start.brightness_, end.brightness_, completion);
    v.color_brightness_ = std::lerp(start.color_brightness_, end.color_brightness_, completion);
    v.red_ = std::lerp(start.red_, end.red_, completion);
    v.green_ = std::lerp(start.green_, end.green_, completion);
    v.blue_ = std::lerp(start.blue_, end.blue_, completion);
    v.white_ = std::lerp(start.white_, end.white_, completion);
    v.color_temperature_ = std::lerp(start.color_temperature_, end.color_temperature_, completion);
    v.cold_white_ = std::lerp(start.cold_white_, end.cold_white_, completion);
    v.warm_white_ = std::lerp(start.warm_white_, end.warm_white_, completion);
    return v;
  }
 
  void normalize_color() {
    if (this->color_mode_ & ColorCapability::RGB) {
      float max_value = fmaxf(this->get_red(), fmaxf(this->get_green(), this->get_blue()));
      if (max_value == 0.0f) {
        this->set_red(1.0f);
        this->set_green(1.0f);
        this->set_blue(1.0f);
      } else {
        this->set_red(this->get_red() / max_value);
        this->set_green(this->get_green() / max_value);
        this->set_blue(this->get_blue() / max_value);
      }
    }
  }
 
  // Note that method signature of as_* methods is kept as-is for compatibility reasons, so not all parameters
  // are always used or necessary. Methods will be deprecated later.
 
  void as_binary(bool *binary) const { *binary = this->state_ == 1.0f; }
 
  void as_brightness(float *brightness, float gamma = 0) const {
    *brightness = gamma_correct(this->state_ * this->brightness_, gamma);
  }
 
  void as_rgb(float *red, float *green, float *blue, float gamma = 0, bool color_interlock = false) const {
    if (this->color_mode_ & ColorCapability::RGB) {
      float brightness = this->state_ * this->brightness_ * this->color_brightness_;
      *red = gamma_correct(brightness * this->red_, gamma);
      *green = gamma_correct(brightness * this->green_, gamma);
      *blue = gamma_correct(brightness * this->blue_, gamma);
    } else {
      *red = *green = *blue = 0;
    }
  }
 
  void as_rgbw(float *red, float *green, float *blue, float *white, float gamma = 0,
               bool color_interlock = false) const {
    this->as_rgb(red, green, blue, gamma);
    if (this->color_mode_ & ColorCapability::WHITE) {
      *white = gamma_correct(this->state_ * this->brightness_ * this->white_, gamma);
    } else {
      *white = 0;
    }
  }
 
  void as_rgbww(float *red, float *green, float *blue, float *cold_white, float *warm_white, float gamma = 0,
                bool constant_brightness = false) const {
    this->as_rgb(red, green, blue, gamma);
    this->as_cwww(cold_white, warm_white, gamma, constant_brightness);
  }
 
  void as_rgbct(float color_temperature_cw, float color_temperature_ww, float *red, float *green, float *blue,
                float *color_temperature, float *white_brightness, float gamma = 0) const {
    this->as_rgb(red, green, blue, gamma);
    this->as_ct(color_temperature_cw, color_temperature_ww, color_temperature, white_brightness, gamma);
  }
 
  void as_cwww(float *cold_white, float *warm_white, float gamma = 0, bool constant_brightness = false) const {
    if (this->color_mode_ & ColorCapability::COLD_WARM_WHITE) {
      const float cw_level = gamma_correct(this->cold_white_, gamma);
      const float ww_level = gamma_correct(this->warm_white_, gamma);
      const float white_level = gamma_correct(this->state_ * this->brightness_, gamma);
      if (!constant_brightness) {
        *cold_white = white_level * cw_level;
        *warm_white = white_level * ww_level;
      } else {
        // Just multiplying by cw_level / (cw_level + ww_level) would divide out the brightness information from the
        // cold_white and warm_white settings (i.e. cw=0.8, ww=0.4 would be identical to cw=0.4, ww=0.2), which breaks
        // transitions. Use the highest value as the brightness for the white channels (the alternative, using cw+ww/2,
        // reduces to cw/2 and ww/2, which would still limit brightness to 100% of a single channel, but isn't very
        // useful in all other aspects -- that behaviour can also be achieved by limiting the output power).
        const float sum = cw_level > 0 || ww_level > 0 ? cw_level + ww_level : 1;  // Don't divide by zero.
        *cold_white = white_level * std::max(cw_level, ww_level) * cw_level / sum;
        *warm_white = white_level * std::max(cw_level, ww_level) * ww_level / sum;
      }
    } else {
      *cold_white = *warm_white = 0;
    }
  }
 
  void as_ct(float color_temperature_cw, float color_temperature_ww, float *color_temperature, float *white_brightness,
             float gamma = 0) const {
    const float white_level = this->color_mode_ & ColorCapability::RGB ? this->white_ : 1;
    if (this->color_mode_ & ColorCapability::COLOR_TEMPERATURE) {
      *color_temperature =
          (this->color_temperature_ - color_temperature_cw) / (color_temperature_ww - color_temperature_cw);
      *white_brightness = gamma_correct(this->state_ * this->brightness_ * white_level, gamma);
    } else {  // Probably won't get here but put this here anyway.
      *white_brightness = 0;
    }
  }
 
  bool operator==(const LightColorValues &rhs) const {
    return color_mode_ == rhs.color_mode_ && state_ == rhs.state_ && brightness_ == rhs.brightness_ &&
           color_brightness_ == rhs.color_brightness_ && red_ == rhs.red_ && green_ == rhs.green_ &&
           blue_ == rhs.blue_ && white_ == rhs.white_ && color_temperature_ == rhs.color_temperature_ &&
           cold_white_ == rhs.cold_white_ && warm_white_ == rhs.warm_white_;
  }
  bool operator!=(const LightColorValues &rhs) const { return !(rhs == *this); }
 
  ColorMode get_color_mode() const { return this->color_mode_; }
  void set_color_mode(ColorMode color_mode) { this->color_mode_ = color_mode; }
 
  float get_state() const { return this->state_; }
  bool is_on() const { return this->get_state() != 0.0f; }
  void set_state(float state) { this->state_ = clamp(state, 0.0f, 1.0f); }
  void set_state(bool state) { this->state_ = state ? 1.0f : 0.0f; }
 
  float get_brightness() const { return this->brightness_; }
  void set_brightness(float brightness) { this->brightness_ = clamp(brightness, 0.0f, 1.0f); }
 
  float get_color_brightness() const { return this->color_brightness_; }
  void set_color_brightness(float brightness) { this->color_brightness_ = clamp(brightness, 0.0f, 1.0f); }
 
  float get_red() const { return this->red_; }
  void set_red(float red) { this->red_ = clamp(red, 0.0f, 1.0f); }
 
  float get_green() const { return this->green_; }
  void set_green(float green) { this->green_ = clamp(green, 0.0f, 1.0f); }
 
  float get_blue() const { return this->blue_; }
  void set_blue(float blue) { this->blue_ = clamp(blue, 0.0f, 1.0f); }
 
  float get_white() const { return white_; }
  void set_white(float white) { this->white_ = clamp(white, 0.0f, 1.0f); }
 
  float get_color_temperature() const { return this->color_temperature_; }
  void set_color_temperature(float color_temperature) { this->color_temperature_ = color_temperature; }
 
  float get_color_temperature_kelvin() const {
    if (this->color_temperature_ <= 0) {
      return this->color_temperature_;
    }
    return 1000000.0 / this->color_temperature_;
  }
  void set_color_temperature_kelvin(float color_temperature) {
    if (color_temperature <= 0) {
      return;
    }
    this->color_temperature_ = 1000000.0 / color_temperature;
  }
 
  float get_cold_white() const { return this->cold_white_; }
  void set_cold_white(float cold_white) { this->cold_white_ = clamp(cold_white, 0.0f, 1.0f); }
 
  float get_warm_white() const { return this->warm_white_; }
  void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); }
 
 protected:
  float state_;  
  float brightness_;
  float color_brightness_;
  float red_;
  float green_;
  float blue_;
  float white_;
  float color_temperature_;  
  float cold_white_;
  float warm_white_;
  ColorMode color_mode_;
};
 
}  // namespace light
}  // namespace esphome