NoteCCKPRangeFastLED.hpp

Go to the documentation of this file.

#if defined(ARDUINO) && defined(FASTLED_VERSION)
#include <FastLED.h>
#endif
 
#include <AH/STL/type_traits> // std::enable_if, std::is_default_constructible
#include <Settings/NamespaceSettings.hpp>
#include <stdint.h>
 
BEGIN_CS_NAMESPACE
 
struct Color {
    uint8_t r;
    uint8_t g;
    uint8_t b;
};
 
Color velocityToNovationColor(uint8_t value);
 
END_CS_NAMESPACE
 
#ifdef FASTLED_VERSION
 
#include <MIDI_Inputs/MIDIInputElement.hpp>
 
BEGIN_CS_NAMESPACE
 
struct DefaultColorMapper {
    CRGB operator()(uint8_t value, uint8_t index) const {
        (void)index;
        Color c = velocityToNovationColor(value);
        return CRGB {c.r, c.g, c.b};
    }
};
 
using index_permuter_f = uint8_t (*)(uint8_t);
 
template <MIDIMessageType Type, uint8_t RangeLen, class ColorMapper>
class NoteCCKPRangeFastLED
    : public MatchingMIDIInputElement<Type, TwoByteRangeMIDIMatcher> {
  public:
    using Matcher = TwoByteRangeMIDIMatcher;
 
    NoteCCKPRangeFastLED(CRGB *ledcolors, MIDIAddress address,
                         const ColorMapper &colormapper)
        : MatchingMIDIInputElement<Type, TwoByteRangeMIDIMatcher>(
              {address, RangeLen}),
          ledcolors(ledcolors), colormapper(colormapper) {}
 
    NoteCCKPRangeFastLED(AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper)
        : NoteCCKPRangeFastLED(ledcolors.data, address, colormapper) {}
 
    NoteCCKPRangeFastLED(CRGB *ledcolors, MIDIAddress address,
                         const ColorMapper &colormapper,
                         index_permuter_f index_permuter)
        : MatchingMIDIInputElement<Type, TwoByteRangeMIDIMatcher>(
              {address, RangeLen}),
          ledcolors(ledcolors), colormapper(colormapper),
          ledIndexPermuter(index_permuter) {}
 
    NoteCCKPRangeFastLED(AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper,
                         index_permuter_f index_permuter)
        : NoteCCKPRangeFastLED(ledcolors.data, address, colormapper,
                               index_permuter) {}
 
    template <class ColorMapper_ = ColorMapper>
    NoteCCKPRangeFastLED(CRGB *ledcolors, MIDIAddress address,
                         typename std::enable_if<std::is_default_constructible<
                             ColorMapper_>::value>::type * = nullptr)
        : MatchingMIDIInputElement<Type, TwoByteRangeMIDIMatcher>(
              {address, RangeLen}),
          ledcolors(ledcolors) {}
 
    template <class ColorMapper_ = ColorMapper>
    NoteCCKPRangeFastLED(AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address,
                         typename std::enable_if<std::is_default_constructible<
                             ColorMapper_>::value>::type * = nullptr)
        : NoteCCKPRangeFastLED(ledcolors.data, address) {}
 
    void setBrightness(uint8_t brightness) { this->brightness = brightness; }
    uint8_t getBrightness() const { return this->brightness; }
 
    void setLEDIndexPermuter(index_permuter_f permuter) {
        this->ledIndexPermuter = permuter ? permuter : identityPermuter;
    }
 
    void begin() override { resetLEDs(); }
 
    void handleUpdate(typename Matcher::Result match) override {
        updateLED(match.index, match.value);
    }
 
    void reset() override { resetLEDs(); }
 
    void updateLED(uint8_t index, uint8_t value) {
        // Apply the color mapper to convert the value and index to a color
        CRGB newColor = CRGB(colormapper(value, index));
        // Apply the brightness to the color
        newColor = newColor.nscale8_video(brightness);
        // Map the note index to the LED index
        uint8_t ledIndex = ledIndexPermuter(index);
        // Check if the color changed
        dirty |= ledcolors[ledIndex] != newColor;
        // Update the LED color
        ledcolors[ledIndex] = newColor;
    }
 
    void resetLEDs() {
        for (uint8_t index = 0; index < RangeLen; ++index)
            updateLED(index, 0);
    }
 
    bool getDirty() const { return dirty; }
    void clearDirty() { dirty = false; }
 
  private:
    CRGB *ledcolors;
    bool dirty = true;
    uint8_t brightness = 255;
    index_permuter_f ledIndexPermuter = identityPermuter;
 
    static uint8_t identityPermuter(uint8_t i) { return i; }
 
  public:
    ColorMapper colormapper;
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
// Everything below is just definitions of type aliases to make the library
// easier to use.
//
// It defines MIDI elements that listen to (a single, a range of)
// (MIDI Note, MIDI Control Change, MIDI Key Pressure) message(s) that display
// the values of these messages using FastLED LEDs or LED strips.
// An optional color mapper can be supplied that defines the mapping from a
// MIDI value [0, 127] to an RGB color.
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
 
template <uint8_t RangeLen, class ColorMapper = DefaultColorMapper>
using NoteRangeFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::NoteOn, RangeLen, ColorMapper>;
 
template <class ColorMapper = DefaultColorMapper>
using NoteValueFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::NoteOn, 1, ColorMapper>;
 
template <uint8_t RangeLen, class ColorMapper = DefaultColorMapper>
using CCRangeFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::ControlChange, RangeLen, ColorMapper>;
 
template <class ColorMapper = DefaultColorMapper>
using CCValueFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::ControlChange, 1, ColorMapper>;
 
template <uint8_t RangeLen, class ColorMapper = DefaultColorMapper>
using KPRangeFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::KeyPressure, RangeLen, ColorMapper>;
 
template <class ColorMapper = DefaultColorMapper>
using KPValueFastLED =
    NoteCCKPRangeFastLED<MIDIMessageType::KeyPressure, 1, ColorMapper>;
 
 
namespace Bankable {
 
struct DefaultColorMapper {
    CRGB operator()(uint8_t value, uint8_t bankIndex, uint8_t index) const {
        (void)bankIndex;
        (void)index;
        Color c = velocityToNovationColor(value);
        return CRGB {c.r, c.g, c.b};
    }
};
 
template <MIDIMessageType Type, uint8_t BankSize, uint8_t RangeLen,
          class ColorMapper>
class NoteCCKPRangeFastLED : public NoteCCKPRange<Type, BankSize, RangeLen> {
  public:
    using Parent = NoteCCKPRange<Type, BankSize, RangeLen>;
    using Matcher = typename Parent::Matcher;
 
    NoteCCKPRangeFastLED(BankConfig<BankSize> config, CRGB *ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper)
        : Parent(config, address), ledcolors(ledcolors),
          colormapper(colormapper) {}
 
    NoteCCKPRangeFastLED(BankConfig<BankSize> config,
                         AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper)
        : NoteCCKPRangeFastLED(config, ledcolors.data, address, colormapper) {}
 
    NoteCCKPRangeFastLED(BankConfig<BankSize> config, CRGB *ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper,
                         index_permuter_f index_permuter)
        : Parent(config, address), ledcolors(ledcolors),
          colormapper(colormapper), ledIndexPermuter(index_permuter) {}
 
    NoteCCKPRangeFastLED(BankConfig<BankSize> config,
                         AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address, const ColorMapper &colormapper,
                         index_permuter_f index_permuter)
        : NoteCCKPRangeFastLED(config, ledcolors.data, address, colormapper,
                               index_permuter) {}
 
    template <class ColorMapper_ = ColorMapper>
    NoteCCKPRangeFastLED(BankConfig<BankSize> config, CRGB *ledcolors,
                         MIDIAddress address,
                         typename std::enable_if<std::is_default_constructible<
                             ColorMapper_>::value>::type * = nullptr)
        : Parent(config, address), ledcolors(ledcolors) {}
 
    template <class ColorMapper_ = ColorMapper>
    NoteCCKPRangeFastLED(BankConfig<BankSize> config,
                         AH::Array<CRGB, RangeLen> &ledcolors,
                         MIDIAddress address,
                         typename std::enable_if<std::is_default_constructible<
                             ColorMapper_>::value>::type * = nullptr)
        : NoteCCKPRangeFastLED(config, ledcolors.data, address) {}
 
    void setBrightness(uint8_t brightness) { this->brightness = brightness; }
    uint8_t getBrightness() const { return this->brightness; }
 
    void setLEDIndexPermuter(index_permuter_f permuter) {
        this->ledIndexPermuter = permuter ? permuter : identityPermuter;
    }
 
    void begin() override { updateLEDs(); }
 
    void handleUpdate(typename Matcher::Result match) override {
        bool newdirty = Parent::handleUpdateImpl(match);
        if (newdirty)
            updateLED(match.bankIndex, match.index, match.value);
        this->dirty |= newdirty;
    }
 
    void reset() override {
        Parent::reset();
        updateLEDs();
    }
 
    void updateLED(uint8_t bankIndex, uint8_t index, uint8_t value) {
        // Apply the color mapper to convert the value and index to a color
        CRGB newColor = CRGB(colormapper(value, bankIndex, index));
        // Apply the brightness to the color
        newColor = newColor.nscale8_video(brightness);
        // Map the note index to the LED index
        uint8_t ledIndex = ledIndexPermuter(index);
        // Update the LED color
        ledcolors[ledIndex] = newColor;
    }
 
    void updateLEDs() {
        const auto bankIndex = this->getActiveBank();
        for (uint8_t index = 0; index < RangeLen; ++index)
            updateLED(bankIndex, index, this->getValue(bankIndex, index));
    }
 
  protected:
    void onBankSettingChange() override {
        Parent::onBankSettingChange();
        updateLEDs();
    }
 
  private:
    CRGB *ledcolors;
    uint8_t brightness = 255;
    index_permuter_f ledIndexPermuter = identityPermuter;
 
    static uint8_t identityPermuter(uint8_t i) { return i; }
 
  public:
    ColorMapper colormapper;
};
 
 
template <uint8_t BankSize, uint8_t RangeLen,
          class ColorMapper = DefaultColorMapper>
using NoteRangeFastLED = NoteCCKPRangeFastLED<MIDIMessageType::NoteOn, BankSize,
                                              RangeLen, ColorMapper>;
 
template <uint8_t BankSize, class ColorMapper = DefaultColorMapper>
using NoteValueFastLED = NoteRangeFastLED<BankSize, 1, ColorMapper>;
 
template <uint8_t BankSize, uint8_t RangeLen,
          class ColorMapper = DefaultColorMapper>
using CCRangeFastLED = NoteCCKPRangeFastLED<MIDIMessageType::ControlChange,
                                            BankSize, RangeLen, ColorMapper>;
 
template <uint8_t BankSize, class ColorMapper = DefaultColorMapper>
using CCValueFastLED = CCRangeFastLED<BankSize, 1, ColorMapper>;
 
template <uint8_t BankSize, uint8_t RangeLen,
          class ColorMapper = DefaultColorMapper>
using KPRangeFastLED = NoteCCKPRangeFastLED<MIDIMessageType::KeyPressure,
                                            BankSize, RangeLen, ColorMapper>;
 
template <uint8_t BankSize, class ColorMapper = DefaultColorMapper>
using KPValueFastLED = KPRangeFastLED<BankSize, 1, ColorMapper>;
 
 
} // namespace Bankable
 
END_CS_NAMESPACE
 
#endif