wt.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/wavetable.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <utility>
#include <vector>
 
namespace pulp::signal::osc {

class WtOscillator {
public:
    static constexpr double kDefaultScanTimeMs = 5.0;

    void set_wavetable_set(std::vector<Wavetable64> tables) {
        ceilings_.clear();
        if (!tables.empty()) {
            const Wavetable64& first = tables.front();
            ceilings_.reserve(first.band_count());
            for (std::size_t b = 0; b < first.band_count(); ++b)
                ceilings_.push_back(first.band_max_frequency_hz(b));
        }
        table_count_ = tables.size();
        bank_ = WavetableBank64(std::move(tables));
        bank_.set_sample_rate(sample_rate_);
        // The fresh bank starts on its default band with nothing audible to fade
        // FROM, so the next frequency must SNAP to its band, not crossfade up from
        // the default — otherwise swapping the wavetable set mid-note replays the
        // aliased band-switch onset that `reset()`'s snap exists to prevent.
        pending_band_snap_ = true;
        update_scan_coeff();
    }

    void prepare(double sample_rate) {
        if (sample_rate > 0.0) sample_rate_ = sample_rate;
        bank_.set_sample_rate(sample_rate_);
        update_scan_coeff();
    }

    void reset() {
        bank_.reset();
        pending_band_snap_ = true;
        scan_position_ = scan_target_;
        bank_.set_position(scan_position_);
    }

    void set_position(double pos) {
        scan_target_ = std::clamp(pos, 0.0, 1.0);
    }

    double position() const { return scan_position_; }

    void set_scan_time_ms(double ms) {
        scan_time_ms_ = ms > 0.0 ? ms : 0.0;
        update_scan_coeff();
    }
    double scan_time_ms() const { return scan_time_ms_; }

    double next(double increment) {
        const double frequency = increment * sample_rate_;
        if (frequency > 0.0) {
            // The first frequency after construction/reset snaps to its band with
            // no crossfade: a fresh voice has no previously audible band to fade
            // FROM, so a crossfade here would play the default band's harmonics at
            // the new pitch for 128 samples — an aliased onset on every note-on.
            // Every later frequency crossfades as normal (a fade between two real
            // playing bands).
            if (pending_band_snap_) {
                bank_.set_frequency_immediate(frequency);
                pending_band_snap_ = false;
            } else {
                bank_.set_frequency(frequency);
            }
        }
 
        // One-pole slew of the scan position toward the target. At coeff 1
        // (scan_time_ms == 0) this is an exact jump; otherwise it is a smooth,
        // click-free approach.
        scan_position_ += (scan_target_ - scan_position_) * scan_coeff_;
        bank_.set_position(scan_position_);
 
        return bank_.next();
    }

    std::size_t band_count() const { return ceilings_.size(); }
    double band_max_frequency_hz(std::size_t i) const {
        return i < ceilings_.size() ? ceilings_[i] : 0.0;
    }

    std::size_t table_count() const { return table_count_; }
 
private:
    void update_scan_coeff() {
        if (scan_time_ms_ <= 0.0 || sample_rate_ <= 0.0) {
            scan_coeff_ = 1.0;
            return;
        }
        const double tau_samples = scan_time_ms_ * 0.001 * sample_rate_;
        scan_coeff_ = 1.0 - std::exp(-1.0 / tau_samples);
    }
 
    WavetableBank64 bank_;
    std::vector<double> ceilings_;
    std::size_t table_count_ = 0;
 
    double sample_rate_ = 48000.0;
    double scan_target_ = 0.0;
    double scan_position_ = 0.0;
    double scan_time_ms_ = kDefaultScanTimeMs;
    double scan_coeff_ = 1.0;
    bool pending_band_snap_ = true;
};
 
} // namespace pulp::signal::osc