hat.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/decay_envelope.hpp>
#include <pulp/signal/drum/voice.hpp>
#include <pulp/signal/noise_source.hpp>
#include <pulp/signal/square_osc_bank.hpp>
#include <pulp/signal/svf.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
 
namespace pulp::signal::drum {

class HatVoice : public Voice {
public:
    static constexpr std::size_t partial_count = 6;

    static constexpr double partial_ratios[partial_count] = {
        1.0, 1.4827, 1.8003, 2.5461, 2.6303, 3.8967};
 
    HatVoice() {
        VelocityResponse r;
        r.level_db = 16.0f;
        r.brightness_octaves = 0.8f;
        set_velocity_response(r);
    }

    void set_tune_hz(double hz) { tune_hz_ = std::clamp(hz, 40.0, 4000.0); }

    void set_decay_ms(double ms) { decay_ms_ = std::clamp(ms, 5.0, 8000.0); }

    void set_spread(double amount) { spread_ = std::clamp(amount, 0.0, 1.0); }

    void set_metal(double amount) { metal_ = std::clamp(amount, 0.0, 1.0); }

    void set_grit(double amount) { grit_ = std::clamp(amount, 0.0, 1.0); }
    void set_grit_ratio(double ratio) { grit_ratio_ = std::clamp(ratio, 0.25, 16.0); }

    void set_cutoff_hz(double hz) { cutoff_hz_ = std::clamp(hz, 200.0, 18000.0); }
    void set_resonance(double q) { resonance_ = std::clamp(q, 0.5, 12.0); }

    void set_bandpass(bool bandpass) { bandpass_ = bandpass; }
 
    void set_noise_color(NoiseColor color) { noise_.set_color(color); }
 
    OutputStage& output() { return output_; }
    const OutputStage& output() const { return output_; }
    OutputStage* output_stage() noexcept override { return &output_; }
    int latency_samples() const noexcept override {
        return output_.latency_samples();
    }
    OutputOversampling output_oversampling() const noexcept override {
        return output_.oversampling();
    }
    void set_output_oversampling(OutputOversampling factor) override {
        output_.set_oversampling(factor);
    }
 
protected:
    void on_prepare(double sample_rate) override {
        noise_.prepare(sample_rate);
        envelope_.set_sample_rate(sample_rate);
        bank_.prepare(static_cast<float>(sample_rate));
 
        SquareOscBank::Partial partials[partial_count];
        bank_.set_partials(partials, partial_count);
        apply_tuning();
 
        filter_.set_sample_rate(static_cast<float>(sample_rate));
        output_.prepare(sample_rate);
    }
 
    void on_reset() override {
        envelope_.reset();
        bank_.reset();
        filter_.reset();
        output_.reset();
        noise_.reset();
        grit_phase_ = 0.0;
    }
 
    void on_note_on(float velocity) override {
        // The oscillator bank survives a retrigger, so its pending output FIR
        // and lo-fi history are part of the same continuing physical state.
        output_.trigger();
        const auto& response = velocity_response();
        velocity_gain_ = response.gain(velocity);
        brightness_ = response.brightness_scale(velocity);
 
        noise_.reset();
        apply_tuning();
        apply_filter();
 
        // The oscillator bank is deliberately not reset. Its phases are what
        // make one hat hit differ from the next: a cymbal is not re-struck from
        // a known state, and restarting the cluster in phase every time is the
        // machine-gun artefact in its most audible form -- every hit would open
        // with the same broadband click.
        envelope_.set_attack_ms(0.3);
        envelope_.set_decay_t60_ms(decay_ms_);
        envelope_.trigger();
    }
 
    bool on_is_active() const override {
        return envelope_.is_active() || output_.has_tail();
    }
 
    void render_add(float* out, int num_samples) override {
        const double noise_mix = 1.0 - metal_;
        for (int i = 0; i < num_samples; ++i) {
            double source = 0.0;
            if (metal_ > 0.0) source += metal_ * static_cast<double>(bank_.process());
            if (noise_mix > 0.0) source += noise_mix * static_cast<double>(noise_.process());
 
            if (grit_ > 0.0) {
                grit_phase_ += tune_hz_ * grit_ratio_ / sample_rate();
                if (grit_phase_ >= 1.0) grit_phase_ -= std::floor(grit_phase_);
                const double modulator =
                    std::sin(2.0 * 3.14159265358979323846 * grit_phase_);
                source *= 1.0 + grit_ * modulator;
            }
 
            const double filtered = filter_.process(static_cast<float>(source));
            const double shaped = filtered * envelope_.process();
            out[i] += static_cast<float>(
                output_.process(static_cast<float>(shaped)) * velocity_gain_);
        }
    }
 
private:
    void apply_tuning() {
        for (std::size_t i = 0; i < partial_count; ++i) {
            // Spread interpolates each oscillator between unison and its
            // documented ratio, so the control is continuous rather than a
            // switch between "square wave" and "hi-hat".
            const double ratio = 1.0 + spread_ * (partial_ratios[i] - 1.0);
            bank_.set_frequency(i, static_cast<float>(
                std::min(tune_hz_ * ratio, 0.49 * sample_rate())));
            bank_.set_amplitude(i, 1.0f / static_cast<float>(partial_count));
        }
    }
 
    void apply_filter() {
        filter_.set_mode(bandpass_ ? Svf::Mode::bandpass : Svf::Mode::highpass);
        filter_.set_frequency(static_cast<float>(
            std::min(cutoff_hz_ * brightness_, 0.49 * sample_rate())));
        filter_.set_resonance(static_cast<float>(resonance_));
    }
 
    double tune_hz_ = 320.0;
    double decay_ms_ = 60.0;
    double spread_ = 1.0;
    double metal_ = 0.8;
    double grit_ = 0.0;
    double grit_ratio_ = 1.4;
    double cutoff_hz_ = 7000.0;
    double resonance_ = 1.2;
    bool bandpass_ = false;
 
    NoiseSource noise_;
    SquareOscBank bank_;
    Svf filter_;
    DecayEnvelope64 envelope_;
    OutputStage output_;
 
    double velocity_gain_ = 1.0;
    double brightness_ = 1.0;
    double grit_phase_ = 0.0;
};
 
}  // namespace pulp::signal::drum