musical_typing.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/input_events.hpp>
 
#include <algorithm>
#include <functional>
#include <unordered_map>
 
namespace pulp::view {
 
class MusicalTypingController {
  public:
    void set_base_note(int note) {
        base_note_ = note;
    }
    int base_note() const {
        return base_note_;
    }
 
    std::function<void(int note, float velocity)> on_note_on;
    std::function<void(int note)> on_note_off;
    float velocity = 0.8f;
    static constexpr float kVelStep = 1.0f / 16.0f; // c / v keyboard velocity step

    bool handle_key(const KeyEvent& e) {
        if (e.modifiers & (kModCmd | kModCtrl | kModAlt | kModMeta))
            return false;
 
        if (e.key == KeyCode::z || e.key == KeyCode::x) {
            if (e.is_down && !e.is_repeat)
                set_octave_shift(octave_shift_ + (e.key == KeyCode::x ? 1 : -1));
            return true;
        }
        // c / v lower / raise the velocity (the design's VELOCITY −c / +v keys),
        // mirroring the z / x octave keys.
        if (e.key == KeyCode::c || e.key == KeyCode::v) {
            if (e.is_down && !e.is_repeat)
                velocity =
                    std::clamp(velocity + (e.key == KeyCode::v ? kVelStep : -kVelStep), 0.0f, 1.0f);
            return true;
        }
        const int semi = semitone_for_key(e.key);
        if (semi < 0)
            return false;
 
        const int kc = static_cast<int>(e.key);
        if (e.is_down) {
            if (held_.count(kc))
                return true; // auto-repeat — already sounding
            const int note = std::clamp(base_note_ + octave_shift_ * 12 + semi, 0, 127);
            held_[kc] = note;
            if (on_note_on)
                on_note_on(note, velocity);
        } else {
            auto it = held_.find(kc);
            if (it != held_.end()) {
                if (on_note_off)
                    on_note_off(it->second);
                held_.erase(it);
            }
        }
        return true;
    }

    int octave_shift() const {
        return octave_shift_;
    }

    void set_octave_shift(int s) {
        const int lo = -((base_note_ + 11) / 12);                // reach C-2 (base > C2)
        const int hi = std::max(5, (92 - base_note_ + 11) / 12); // reach G8 (low roots)
        octave_shift_ = std::clamp(s, lo, hi);
    }

    void all_notes_off() {
        for (const auto& [kc, note] : held_)
            if (on_note_off)
                on_note_off(note);
        held_.clear();
    }
 
    bool any_held() const {
        return !held_.empty();
    }

    static int semitone_for_key(KeyCode k) {
        switch (k) {
        case KeyCode::a:
            return 0;
        case KeyCode::w:
            return 1;
        case KeyCode::s:
            return 2;
        case KeyCode::e:
            return 3;
        case KeyCode::d:
            return 4;
        case KeyCode::f:
            return 5;
        case KeyCode::t:
            return 6;
        case KeyCode::g:
            return 7;
        case KeyCode::y:
            return 8;
        case KeyCode::h:
            return 9;
        case KeyCode::u:
            return 10;
        case KeyCode::j:
            return 11;
        case KeyCode::k:
            return 12;
        case KeyCode::o:
            return 13;
        case KeyCode::l:
            return 14;
        case KeyCode::p:
            return 15;
        case KeyCode::semicolon:
            return 16;
        case KeyCode::apostrophe:
            return 17;
        default:
            return -1;
        }
    }
 
  private:
    int base_note_ = 60;
    int octave_shift_ = 0;
    std::unordered_map<int, int> held_; // keyCode -> note currently sounding
};
 
} // namespace pulp::view