part.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/control_matrix.hpp"
#include "tabulasonora/lfo_engine.hpp"
#include "tabulasonora/part_modifiers.hpp"
#include "tabulasonora/pitch_chain.hpp"
#include "tabulasonora/sequence.hpp"
#include "tabulasonora/tva_chain.hpp"
 
#include <algorithm>
#include <array>
#include <cstdlib>
#include <vector>
 
namespace ts {

struct RxSwitches {
    bool pitch_bend = true;
    bool channel_pressure = true;
    bool program_change = true;
    bool control_change = true;
    bool poly_pressure = true;
    bool notes = true;
    bool rpn = true;
    bool nrpn = true;
    bool modulation = true;
    bool volume = true;
    bool panpot = true;
    bool expression = true;
    bool hold = true;
    bool portamento = true;
    bool sostenuto = true;
    bool soft = true;
    bool bank_msb = true;
    bool bank_lsb = true;
};

class Part {
public:
    Part() { recompute(); }

    int program = 0;
    int bank = 0;
    int bank_lsb = 0;

    int rx_channel = 0;

    RxSwitches rx;
    int pan = sequence_builder::default_pan;
    int modulation = 0;
    int damper = 0;
    int reverb_send = sequence_builder::default_reverb_send;
    int chorus_send = sequence_builder::default_chorus_send;
    int delay_send = 0;

    int bend = 8192;
    int bend_range = 2;
    int fine_tune = 0x2000;
    int coarse_tune = 0x40;
    int key_shift = 0x40;

    ControlMatrix control;

    int channel_pressure = 0;

    int cc1_number = 16;
    int cc2_number = 17;
    int cc1 = 0;
    int cc2 = 0;

    int xg_bank_msb = -1;

    std::array<std::uint8_t, 128> poly_pressure{};

    [[nodiscard]] int key_pressure(int note) const noexcept
    {
        return note >= 0 && note < 128 ? poly_pressure[static_cast<std::size_t>(note)] : 0;
    }

    int vibrato_rate = 0x40;
    int vibrato_depth = 0x40;
    int vibrato_delay = 0x40;
    int tvf_cutoff = 0x40;
    int env_attack = 0x40;
    int env_decay = 0x40;
    int env_release = 0x40;

    int tvf_resonance = 0x40;

    [[nodiscard]] PartModifiers modifiers() const noexcept
    {
        return PartModifiers{vibrato_rate,
                             vibrato_depth,
                             vibrato_delay,
                             tvf_cutoff,
                             env_attack,
                             env_decay,
                             env_release};
    }

    [[nodiscard]] int effective_velocity(int velocity) const noexcept
    {
        int value = velocity;
        if (velocity_depth == 0) {
            value = 1;
        } else if (velocity_depth != 0x40) {
            value = (value * velocity_depth) >> 6;
        }
 
        value += (velocity_offset - 0x40) * 2;
        if (value < 0) {
            return 1;
        }
        return value > 0x7F ? 0x7F : value;
    }

    std::array<int, 12> scale_tuning{
        0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40};

    int rhythm = -1;

    int key_low = 0;
    int key_high = 0x7F;

    bool eq_enabled = false;

    bool efx_enabled = false;

    int velocity_depth = 0x40;
    int velocity_offset = 0x40;

    int pitch_offset_fine = 0x08;
 
    int rpn_msb = 0x7F;
    int rpn_lsb = 0x7F;
    int nrpn_msb = 0x7F;
    int nrpn_lsb = 0x7F;

    bool data_entry_is_nrpn = false;

    DrumKeyOverrides drum_keys;

    std::vector<int> sustained;

    int portamento_time = 0;
    bool portamento_on = false;
    bool mono = false;

    bool soft = false;

    int portamento_control_key = -1;

    int last_key = -1;

    bool sostenuto_down = false;

    std::vector<int> sostenuto_captured;

    std::vector<int> sostenuto_released;

    [[nodiscard]] bool damper_down() const noexcept { return damper >= 0x40; }

    [[nodiscard]] int volume() const noexcept { return volume_; }
 
    void set_volume(int value) noexcept
    {
        volume_ = value;
        recompute();
    }

    [[nodiscard]] int expression() const noexcept { return expression_; }
 
    void set_expression(int value) noexcept
    {
        expression_ = value;
        recompute();
    }

    [[nodiscard]] int master() const noexcept { return master_; }
 
    void set_master(int value) noexcept
    {
        master_ = value;
        recompute();
    }

    [[nodiscard]] double volume_scale() const noexcept { return volume_scale_; }

    [[nodiscard]] ControlMatrix::Modulation matrix(int key_pressure = 0) const noexcept
    {
        ControlMatrix::Modulation sums =
            control.applied_linear(ControlMatrix::Source::modulation, modulation);
        sums += control.applied_linear(ControlMatrix::Source::channel_pressure, channel_pressure);
        sums += control.applied_linear(ControlMatrix::Source::poly_pressure, key_pressure);
        sums += control.applied_linear(ControlMatrix::Source::cc1, cc1);
        sums += control.applied_linear(ControlMatrix::Source::cc2, cc2);
        sums += control.applied_bipolar(
            ControlMatrix::Source::bend, bend - 8192, bend_range + ControlMatrix::neutral);
        return ControlMatrix::scaled(sums);
    }

    [[nodiscard]] double matrix_pitch_milli_semitones(int key_pressure = 0) const noexcept
    {
        return static_cast<double>(matrix(key_pressure).pitch);
    }

    [[nodiscard]] double bend_milli_semitones() const noexcept
    {
        return PitchChain::bend_offset_milli_semitones(bend, bend_range);
    }

    [[nodiscard]] double tune_milli_semitones() const noexcept
    {
        return ((key_shift - 0x40) * 1000.0) + ((coarse_tune - 0x40) * 1000.0)
               + ((fine_tune - 0x2000) * 1000.0 / 0x2000);
    }

    [[nodiscard]] double scale_offset_milli_semitones(int key) const noexcept
    {
        return (scale_tuning[static_cast<std::size_t>(((key % 12) + 12) % 12)] - 0x40) * 10.0;
    }

    [[nodiscard]] bool rpn_is_null() const noexcept { return rpn_msb == 0x7F && rpn_lsb == 0x7F; }

    void reset();

    void reset_controllers()
    {
        set_expression(sequence_builder::default_expression);
        bend = 8192;
        damper = 0;
        soft = false;
        modulation = 0;
        channel_pressure = 0;
        poly_pressure.fill(0);
        portamento_on = false;
        portamento_control_key = -1;
        rpn_msb = 0x7F;
        rpn_lsb = 0x7F;
        nrpn_msb = 0x7F;
        nrpn_lsb = 0x7F;
        data_entry_is_nrpn = false;
    }
 
private:
    void recompute() noexcept
    {
        volume_scale_ = TvaChain::part_volume_scale(volume_, expression_, master_);
    }
 
    int volume_ = sequence_builder::default_volume;
    int expression_ = sequence_builder::default_expression;
    int master_ = sequence_builder::default_master;
    double volume_scale_ = 1.0;
};
 
} // namespace ts