note_renderer.hpp

Go to the documentation of this file.

#pragma once
 
#include "tabulasonora/drum_kit_table.hpp"
#include "tabulasonora/engine_noise.hpp"
#include "tabulasonora/interpolator.hpp"
#include "tabulasonora/lfo_engine.hpp"
#include "tabulasonora/patch_directory.hpp"
#include "tabulasonora/pitch_chain.hpp"
#include "tabulasonora/sampler.hpp"
#include "tabulasonora/table_set.hpp"
#include "tabulasonora/tva_chain.hpp"
#include "tabulasonora/tvf_chain.hpp"
#include "tabulasonora/wave_rom.hpp"
 
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
namespace ts {

struct RenderedNote {
    std::vector<float> left;
    std::vector<float> right;
    std::vector<float> mono;
    std::string name;
};

class NoteRenderer {
public:
    static constexpr int control_block = 320;

    static constexpr int sample_rate = 32000;

    static constexpr double max_drum_ring_scale = 16.0;

    explicit NoteRenderer(const RomImage& rom);
 
    NoteRenderer(NoteRenderer&&) noexcept;
    NoteRenderer& operator=(NoteRenderer&&) noexcept;
    NoteRenderer(const NoteRenderer&) = delete;
    NoteRenderer& operator=(const NoteRenderer&) = delete;
    ~NoteRenderer();

    struct Controllers {
        std::span<const double> volume;
        std::span<const double> pitch_add;
        std::span<const double> mod_wheel_per_tick;
    };

    [[nodiscard]] const RomImage& rom() const noexcept;

    [[nodiscard]] const TableSet& tables() const noexcept;

    [[nodiscard]] EngineNoise& noise() noexcept;

    [[nodiscard]] const PatchDirectory& directory() const noexcept;

    [[nodiscard]] const DrumKitTable& drums() const noexcept;

    [[nodiscard]] const Interpolator& interpolator() const noexcept;

    [[nodiscard]] Sampler& sampler() noexcept;

    [[nodiscard]] const EnvelopeMachine& envelopes() const noexcept;

    [[nodiscard]] const TvaChain& tva() const noexcept;

    [[nodiscard]] const TvfChain& tvf() const noexcept;

    [[nodiscard]] const PitchChain& pitch() const noexcept;

    [[nodiscard]] const LfoEngine& lfo() const noexcept;

    [[nodiscard]] const PanLaw& pan() const noexcept;

    [[nodiscard]] RenderedNote render_note(int program,
                                           int note,
                                           int velocity,
                                           double hold_seconds,
                                           double tail_seconds,
                                           ToneMap map = ToneMap::sc8820,
                                           int bank = 0,
                                           int part_pan = 0x40,
                                           const Controllers& controllers = {});

    [[nodiscard]] static double drum_ring_scale(const DrumKey& key) noexcept;

    [[nodiscard]] double drum_ring_scale(int note, int kit, int drum_pitch) const;

    [[nodiscard]] RenderedNote render_drum_note(int note,
                                                int velocity,
                                                double ring_seconds,
                                                double tail_seconds = 0.4,
                                                int kit = 0,
                                                std::span<const double> volume = {},
                                                int drum_pitch = 0,
                                                std::optional<int> drum_pan = std::nullopt);

    [[nodiscard]] static int envelope_rate_key(const DrumKey& key, int drum_pitch) noexcept;

    [[nodiscard]] static std::vector<double> expand(std::span<const double> ticks,
                                                    std::size_t sample_count);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
} // namespace ts