fixed_modes.hpp

Go to the documentation of this file.

#ifndef FIXED_MODES_H
#define FIXED_MODES_H
 
 
#include "src/modes/include/colors/palettes.hpp"
 
#include "src/modes/include/anims/fadeout.hpp"
 
namespace lampda {
 
namespace modes {
 
namespace fixed {
 
template<bool isStep = false, uint32_t rampUpdateLenght_ms = 55, bool shouldSaturateRamp = false> struct PaletteMode :
  public modes::BasicMode
{
  static constexpr uint8_t dissolveBufferId = 0;
  inline static anims::fadeout::GravityDissolve<dissolveBufferId> sunsetAnimation =
          anims::fadeout::GravityDissolve<dissolveBufferId>();
 
  static void on_enter_mode(auto& ctx)
  {
    // saturate the ramp
    ctx.template set_config_bool<ConfigKeys::rampSaturates>(shouldSaturateRamp);
    //
    ctx.template set_config_bool<ConfigKeys::customRampAnimEffect>(false);
    // this ramps should be slow
    ctx.template set_config_u32<ConfigKeys::customRampStepSpeedMs>(rampUpdateLenght_ms);
 
    sunsetAnimation.reset(ctx);
 
    // display a ramp
    ctx.overlay_animate_ramp(255, ctx.state.palette, 1000);
  }
 
  static void loop(auto& ctx)
  {
    // clear previous animation
    ctx.lamp.clear();
 
    const uint8_t customRamp = ctx.get_active_custom_ramp();
    uint32_t color = modes::colors::from_palette<not shouldSaturateRamp>(
            // if palette is stepped, remove all intermediate colors
            static_cast<uint8_t>(isStep ? (customRamp >> 4) << 4 : customRamp),
            // not stepped, allow interpolation
            ctx.state.palette);
 
    // fill, with mask
    ctx.lamp.fill(color, ctx.lamp.template getTempBuffer<dissolveBufferId>());
 
    // update animation
    sunsetAnimation.loop(ctx, color);
  }
 
  static void sunset_update(auto& ctx, float progress) { sunsetAnimation.update_depop_rate(ctx, progress); }
 
  static constexpr bool hasCustomRamp = true;
  static constexpr bool hasSunsetAnimation = true;
};
 
struct PaletteRainbowMode : public PaletteMode<false>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PaletteRainbowColors;
  };
};
 
struct PaletteBlackBodyMode : public PaletteMode<false, 30, true>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PaletteBlackBodyColors;
  };
};
 
struct PalettePartyMode : public PaletteMode<false>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PalettePartyColors;
  };
};
 
struct PaletteForestMode : public PaletteMode<false>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PaletteForestColors;
  };
};
 
struct PaletteOceanMode : public PaletteMode<false>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PaletteOceanColors;
  };
};
 
struct PalettePapiMode : public PaletteMode<true>
{
  struct StateTy
  {
    static constexpr modes::colors::PaletteTy palette = modes::colors::PalettePapiColors;
  };
};
 
} // namespace fixed
 
using FixedModes = modes::GroupFor<fixed::PaletteBlackBodyMode, fixed::PaletteRainbowMode, fixed::PalettePapiMode>;
using MiscFixedModes = modes::GroupFor<fixed::PalettePartyMode, fixed::PaletteForestMode, fixed::PaletteOceanMode>;
 
} // namespace modes
} // namespace lampda
 
#endif