gravity_mode.hpp

Go to the documentation of this file.

#ifndef GRAVITY_MODE_H
#define GRAVITY_MODE_H
 
 
#include "src/modes/include/imu/utils.hpp"
 
#include "src/modes/include/colors/palettes.hpp"
#include <cstddef>
#include <cstdint>
#include <functional>
 
namespace lampda::modes::default_modes {
 
struct GravityMode : public BasicMode
{
  static constexpr bool hasCustomRamp = true;
  static constexpr uint16_t particleCount = 255;
 
  static void on_enter_mode(auto& ctx)
  {
    auto& state = ctx.state;
 
    state.imuEvent.reset(ctx);
    // set particle count
    state.imuEvent.particuleSystem.set_max_particle_count(particleCount);
    state.imuEvent.particuleSystem.init_particules(generate_random_particule_position);
 
    state.persistance = 210;
 
    // set default value
    custom_ramp_update(ctx, ctx.get_active_custom_ramp());
  }
 
  static uint8_t get_custom_ramp_default_value(auto& ctx)
  {
    // start with aurora palette
    return 0;
  }
 
  static void custom_ramp_update(auto& ctx, uint8_t rampValue)
  {
    auto& state = ctx.state;
 
    const uint8_t rampIndex =
            std::min<uint8_t>(floorf(rampValue / 255.0f * state.maxPalettesCount), state.maxPalettesCount - 1.0f);
 
    state.selectedPalette = state._palettes[rampIndex];
  }
 
  static void loop(auto& ctx)
  {
    auto& state = ctx.state;
    if (!state.selectedPalette)
      return;
 
    const uint8_t paletteWrap = ctx.lamp.tick % UINT8_MAX;
 
    state.imuEvent.update(ctx);
 
    auto& particleSystem = state.imuEvent.particuleSystem;
 
    particleSystem.iterate_with_collisions(state.imuEvent.lastReading.accel, ctx.lamp.frameDurationMs / 1000.0f);
 
    ctx.lamp.fadeToBlackBy(255 - ctx.state.persistance);
 
    auto colorFunction = [&](int16_t n, const Particle& particle) {
      const auto wrapIndex = (n + paletteWrap) % particleCount;
      return colors::from_palette(static_cast<uint8_t>(wrapIndex / static_cast<float>(particleCount) * UINT8_MAX),
                                  *state.selectedPalette);
    };
    particleSystem.show(colorFunction, ctx.lamp);
  }
 
  struct StateTy
  {
    uint8_t persistance;
    imu::ImuEventTy<> imuEvent;
 
    static constexpr uint8_t maxPalettesCount = 3;
    const colors::PaletteTy* _palettes[maxPalettesCount] = {
            &colors::PaletteAuroraColors, &colors::PaletteForestColors, &colors::PaletteOceanColors};
 
    colors::PaletteTy const* selectedPalette;
  };
 
private:
  using LampTy = hardware::LampTy;
 
  static int16_t generate_random_particule_position(size_t) { return random16(LampTy::ledCount); }
  static int16_t generate_particule_at_top_random_position(size_t)
  {
    return -static_cast<float>(random16(2.0 * LampTy::maxWidth));
  }
  static int16_t generate_particule_at_bottom_random_position(size_t)
  {
    return LampTy::ledCount + static_cast<float>(random16(2.0 * LampTy::maxWidth));
  }
 
  static int16_t generate_particule_at_extremes(size_t i)
  {
    return (i % 2 == 0) ? generate_particule_at_top_random_position(i) :
                          generate_particule_at_bottom_random_position(i);
  }
 
  static bool recycle_particules_if_too_far(const Particle& p)
  {
    return p.z_mm > LampTy::maxWidth * 3 or p.z_mm < -(LampTy::lampHeight_mm + LampTy::maxWidth * 3);
  }
};
 
} // namespace lampda::modes::default_modes
 
#endif // BEATSYNC_MODE_H