lfo_engine.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/engine_noise.hpp"
#include "tabulasonora/part_modifiers.hpp"
#include "tabulasonora/partial_parameters.hpp"
#include "tabulasonora/table_set.hpp"
 
#include <cstdint>
#include <span>
#include <utility>
#include <vector>
 
namespace ts {

enum class LfoDestination {
    pitch,
    tvf,
    tva,
};

struct LfoConfig {
    int waveform = 0;
    int initial_phase = 0;
    int increment = 0;
    int delay_rate = 0;
    int fade_rate = 0;
    int pitch_depth = 0;
    int tvf_depth = 0;
    int tva_depth = 0;

    [[nodiscard]] constexpr int depth(LfoDestination destination) const noexcept
    {
        switch (destination) {
        case LfoDestination::pitch:
            return pitch_depth;
        case LfoDestination::tvf:
            return tvf_depth;
        case LfoDestination::tva:
            break;
        }
        return tva_depth;
    }
};
 
class LfoRunner;

class LfoEngine {
public:
    static constexpr double waveform_scale = 32640.0;

    [[nodiscard]] static constexpr bool is_random(int waveform) noexcept
    {
        return waveform >= 1 && waveform <= 3;
    }

    static constexpr int slew_step = 0x50;

    struct Limits {
        int clamp = 0;
        int rounding = 0;
    };
 
    [[nodiscard]] static constexpr Limits destination_limits(LfoDestination destination) noexcept
    {
        switch (destination) {
        case LfoDestination::tva:
            return Limits{0x7F00, 0xFFFF};
        case LfoDestination::tvf:
            return Limits{0x1800, 0x8000};
        case LfoDestination::pitch:
            break;
        }
        return Limits{6000, 0x8000};
    }

    explicit LfoEngine(const TableSet& tables, EngineNoise* noise = nullptr);

    [[nodiscard]] EngineNoise& noise() const noexcept { return *noise_; }

    [[nodiscard]] int waveform(int phase, int waveform_index) const noexcept;

    [[nodiscard]] std::pair<LfoConfig, LfoConfig>
    configure(int tone_number,
              const PartialParameters& partial,
              const PartModifiers& modifiers = {}) const;

    [[nodiscard]] LfoRunner create_runner(const LfoConfig& config) const;

    [[nodiscard]] std::pair<LfoRunner, LfoRunner>
    create_runners(int tone_number,
                   const PartialParameters& partial,
                   const PartModifiers& modifiers = {}) const;

    [[nodiscard]] std::vector<double>
    run(const LfoConfig& config, int tick_count, LfoDestination destination) const;

    [[nodiscard]] std::vector<double> modulation(int tone_number,
                                                 const PartialParameters& partial,
                                                 int tick_count,
                                                 LfoDestination destination) const;

    [[nodiscard]] std::vector<double>
    pitch_modulation_with_wheel(int tone_number,
                                const PartialParameters& partial,
                                int tick_count,
                                std::span<const double> mod_depth_per_tick) const;

    [[nodiscard]] static int
    mod_wheel_depth(int controller, int depth = 0x0A, int offset = 0) noexcept;
 
private:
    [[nodiscard]] std::vector<double> run_pitch_with_wheel(
        const LfoConfig& config, int tick_count, std::span<const double> mod_depth_per_tick) const;
 
    std::span<const std::uint8_t> half_sine_;
    std::span<const std::uint16_t> rate_table_;
    std::span<const std::uint16_t> cents_table_;
    std::span<const std::uint16_t> delay_table_;
    std::span<const std::uint8_t> wave_map_;
    std::span<const std::int16_t> wave_bank_;
    std::span<const std::uint8_t> tone_;
 
    EngineNoise* noise_;
    EngineNoise owned_noise_;
};

class LfoRunner {
public:
    LfoRunner(const LfoEngine& engine, const LfoConfig& config)
        : engine_(&engine), config_(config), phase_(config.initial_phase & 0xFFFF)
    {
    }

    [[nodiscard]] const LfoConfig& config() const noexcept { return config_; }

    [[nodiscard]] bool is_applied() const noexcept { return applied_; }

    void tick(int rate_offset = 0) noexcept;

    [[nodiscard]] double value(LfoDestination destination, int matrix_depth = 0) const noexcept;

    [[nodiscard]] double pitch_value(double wheel_depth) const noexcept;
 
private:
    void advance_waveform(bool wrapped) noexcept;
 
    [[nodiscard]] int faded(int depth) const noexcept;
    [[nodiscard]] double apply(int effective, int rounding) const noexcept;
 
    const LfoEngine* engine_;
    LfoConfig config_;
 
    int phase_ = 0;
    int delay_ = 0;
    int fade_ = 0;
    bool applied_ = false;

    int output_ = 0;

    int held_ = 0;
    int slewed_ = 0;
};
 
} // namespace ts