control_matrix.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cstdlib>
 
namespace ts {

struct ControlMatrix {
    enum class Source {
        modulation = 0,   
        bend = 1,         
        channel_pressure, 
        poly_pressure,    
        cc1,              
        cc2,              
    };

    enum class Destination {
        pitch = 0,  
        tvf_cutoff, 
        amplitude,  
        lfo1_rate,  
        lfo1_pitch, 
        lfo1_tvf,   
        lfo1_tva,   
        lfo2_rate,  
        lfo2_pitch, 
        lfo2_tvf,   
        lfo2_tva,   
    };
 
    static constexpr int source_count = 6;
    static constexpr int destination_count = 11;

    static constexpr int neutral = 0x40;

    static constexpr int default_modulation_lfo1_pitch = 0x0A;

    std::array<std::array<int, destination_count>, source_count> depth{};
 
    ControlMatrix() noexcept { reset(); }

    void reset() noexcept
    {
        for (auto& source : depth) {
            // The three continuous destinations and the two LFO rates are bipolar and centre at
            // 0x40; the six LFO depths are amounts and start at zero.
            source = {neutral, neutral, neutral, neutral, 0, 0, 0, neutral, 0, 0, 0};
        }
        at(Source::modulation, Destination::lfo1_pitch) = default_modulation_lfo1_pitch;
 
        // Bend's pitch depth is deliberately absent here — see `bend_pitch_lives_in_bend_range`.
    }
 
    [[nodiscard]] int& at(Source source, Destination destination) noexcept
    {
        return depth[static_cast<std::size_t>(source)][static_cast<std::size_t>(destination)];
    }
 
    [[nodiscard]] int at(Source source, Destination destination) const noexcept
    {
        return depth[static_cast<std::size_t>(source)][static_cast<std::size_t>(destination)];
    }

    void store(Source source, Destination destination, int value) noexcept
    {
        at(source, destination) =
            destination == Destination::pitch ? std::clamp(value, 0x28, 0x58) : value;
    }

    struct Modulation {
        int pitch = 0;      
        int tvf_cutoff = 0; 
        int amplitude = 0;  
        int lfo1_rate = 0;
        int lfo1_pitch = 0;
        int lfo1_tvf = 0;
        int lfo1_tva = 0;
        int lfo2_rate = 0;
        int lfo2_pitch = 0;
        int lfo2_tvf = 0;
        int lfo2_tva = 0;

        [[nodiscard]] constexpr int at(Destination destination) const noexcept
        {
            switch (destination) {
            case Destination::pitch:
                return pitch;
            case Destination::tvf_cutoff:
                return tvf_cutoff;
            case Destination::amplitude:
                return amplitude;
            case Destination::lfo1_rate:
                return lfo1_rate;
            case Destination::lfo1_pitch:
                return lfo1_pitch;
            case Destination::lfo1_tvf:
                return lfo1_tvf;
            case Destination::lfo1_tva:
                return lfo1_tva;
            case Destination::lfo2_rate:
                return lfo2_rate;
            case Destination::lfo2_pitch:
                return lfo2_pitch;
            case Destination::lfo2_tvf:
                return lfo2_tvf;
            case Destination::lfo2_tva:
                break;
            }
            return lfo2_tva;
        }

        constexpr Modulation& operator+=(const Modulation& other) noexcept
        {
            pitch += other.pitch;
            tvf_cutoff += other.tvf_cutoff;
            amplitude += other.amplitude;
            lfo1_rate += other.lfo1_rate;
            lfo1_pitch += other.lfo1_pitch;
            lfo1_tvf += other.lfo1_tvf;
            lfo1_tva += other.lfo1_tva;
            lfo2_rate += other.lfo2_rate;
            lfo2_pitch += other.lfo2_pitch;
            lfo2_tvf += other.lfo2_tvf;
            lfo2_tva += other.lfo2_tva;
            return *this;
        }
    };

    [[nodiscard]] Modulation applied_linear(Source source, int amount) const noexcept
    {
        const auto& row = depth[static_cast<std::size_t>(source)];
 
        // A bipolar destination, halved. `(|d| * amount) >> 1` with the sign put back.
        const auto halved = [amount](int value) {
            const int offset = value - neutral;
            const int magnitude = (std::abs(offset) * amount) >> 1;
            return offset < 0 ? -magnitude : magnitude;
        };
 
        // A unipolar depth, quartered. No 0x40 offset: zero means none.
        const auto quartered = [amount](int value) { return (value * amount) >> 2; };
 
        return Modulation{
            .pitch = (row[0] - neutral) * amount,
            .tvf_cutoff = halved(row[1]),
            .amplitude = halved(row[2]),
            .lfo1_rate = halved(row[3]),
            .lfo1_pitch = quartered(row[4]),
            .lfo1_tvf = quartered(row[5]),
            .lfo1_tva = quartered(row[6]),
            .lfo2_rate = halved(row[7]),
            .lfo2_pitch = quartered(row[8]),
            .lfo2_tvf = quartered(row[9]),
            .lfo2_tva = quartered(row[10]),
        };
    }

    [[nodiscard]] Modulation
    applied_bipolar(Source source, int amount, int pitch_depth = neutral) const noexcept
    {
        const auto& row = depth[static_cast<std::size_t>(source)];
        const int magnitude = (amount < 0 ? -amount : amount) << 2;
        const bool amount_negative = amount < 0;
 
        // A destination measured from centre, whose sign combines with the amount's.
        const auto centred = [magnitude, amount_negative](int value, int constant) {
            const int offset = value - neutral;
            if (offset == 0) {
                return 0;
            }
            const int scaled =
                static_cast<int>((static_cast<unsigned>(std::abs(offset) * magnitude) >> 8)
                                     * static_cast<unsigned>(constant)
                                 >> 16);
            return (offset < 0) != amount_negative ? -scaled : scaled;
        };
 
        // A unipolar depth: zero means none, so only the amount carries a sign.
        const auto amountwise = [magnitude, amount_negative](int value, int constant) {
            if (value == 0) {
                return 0;
            }
            const int scaled = static_cast<int>((static_cast<unsigned>(value * magnitude) >> 8)
                                                    * static_cast<unsigned>(constant)
                                                >> 16);
            return amount_negative ? -scaled : scaled;
        };
 
        constexpr int whole = 0xFE16;
        constexpr int half = 0x7F00;
        constexpr int quarter = 0x3F81;
 
        return Modulation{
            .pitch = centred(pitch_depth, whole),
            .tvf_cutoff = centred(row[1], half),
            .amplitude = centred(row[2], half),
            .lfo1_rate = centred(row[3], half),
            .lfo1_pitch = amountwise(row[4], quarter),
            .lfo1_tvf = amountwise(row[5], quarter),
            .lfo1_tva = amountwise(row[6], quarter),
            .lfo2_rate = centred(row[7], half),
            .lfo2_pitch = amountwise(row[8], quarter),
            .lfo2_tvf = amountwise(row[9], quarter),
            .lfo2_tva = amountwise(row[10], quarter),
        };
    }

    struct Law {
        int clamp;
        int shift;
        int multiplier;
    };

    [[nodiscard]] static constexpr Law law(Destination destination) noexcept
    {
        switch (destination) {
        case Destination::pitch:
            return Law{0xBE8, 3, 0xFBF8};
        case Destination::tvf_cutoff:
            return Law{4000, 3, 0xC49C};
        case Destination::amplitude:
            return Law{4000, 4, 0x820D};
        case Destination::lfo1_rate:
        case Destination::lfo2_rate:
            return Law{4000, 1, 0xD1B8};
        case Destination::lfo1_pitch:
        case Destination::lfo2_pitch:
            return Law{0xFC0, 1, 0xBE7A};
        case Destination::lfo1_tvf:
        case Destination::lfo2_tvf:
            return Law{0xFC0, 1, 0xC30D};
        case Destination::lfo1_tva:
        case Destination::lfo2_tva:
            break;
        }
        return Law{0xFC0, 4, 0x8105};
    }

    [[nodiscard]] static constexpr int scaled(Destination destination, int sum) noexcept
    {
        if (sum == 0) {
            return 0;
        }
 
        const Law rule = law(destination);
        const unsigned magnitude =
            static_cast<unsigned>(std::min(std::abs(sum), rule.clamp) << rule.shift);
        const int value =
            static_cast<int>((magnitude * static_cast<unsigned>(rule.multiplier)) >> 16);
        return sum < 0 ? -value : value;
    }

    [[nodiscard]] static constexpr Modulation scaled(const Modulation& sums) noexcept
    {
        return Modulation{
            .pitch = scaled(Destination::pitch, sums.pitch),
            .tvf_cutoff = scaled(Destination::tvf_cutoff, sums.tvf_cutoff),
            .amplitude = scaled(Destination::amplitude, sums.amplitude),
            .lfo1_rate = scaled(Destination::lfo1_rate, sums.lfo1_rate),
            .lfo1_pitch = scaled(Destination::lfo1_pitch, sums.lfo1_pitch),
            .lfo1_tvf = scaled(Destination::lfo1_tvf, sums.lfo1_tvf),
            .lfo1_tva = scaled(Destination::lfo1_tva, sums.lfo1_tva),
            .lfo2_rate = scaled(Destination::lfo2_rate, sums.lfo2_rate),
            .lfo2_pitch = scaled(Destination::lfo2_pitch, sums.lfo2_pitch),
            .lfo2_tvf = scaled(Destination::lfo2_tvf, sums.lfo2_tvf),
            .lfo2_tva = scaled(Destination::lfo2_tva, sums.lfo2_tva),
        };
    }

    static constexpr bool bend_pitch_lives_in_bend_range = true;
};
 
} // namespace ts