layers.hpp

Go to the documentation of this file.

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

class ClickLayer {
public:
    void prepare(double sample_rate) {
        sample_rate_ = sample_rate;
        envelope_.set_sample_rate(sample_rate);
        filter_.prepare(static_cast<float>(sample_rate));
        apply_cutoff();
        reset();
    }
 
    void reset() {
        envelope_.reset();
        filter_.reset();
    }
 
    void set_level(double level) {
        level_ = std::max(level, 0.0);
        if (level_ == 0.0) reset();
    }
    void set_cutoff_hz(double hz) {
        cutoff_hz_ = std::clamp(hz, 20.0, 20000.0);
        apply_cutoff();
    }
    void set_decay_ms(double ms) {
        decay_ms_ = std::clamp(ms, 0.05, 200.0);
        envelope_.set_decay_time_constant_ms(decay_ms_);
    }
 
    double level() const { return level_; }
    double cutoff_hz() const { return cutoff_hz_; }

    void trigger(double brightness = 1.0) {
        if (level_ <= 0.0) return;
        brightness_ = std::max(brightness, 0.01);
        apply_cutoff();
        // The filter starts clean on every hit: a strike is a fresh event, and
        // leaving state behind would make a hit depend on how long ago the
        // previous one was.
        filter_.reset();
        envelope_.set_attack_ms(0.0);
        envelope_.set_decay_time_constant_ms(decay_ms_);
        envelope_.trigger();
    }

    bool is_active() const { return level_ > 0.0 && envelope_.is_active(); }

    double process(double noise) {
        if (!envelope_.is_active() || level_ <= 0.0) return 0.0;
        const double filtered = filter_.process_lowpass(static_cast<float>(noise));
        return filtered * envelope_.process() * level_;
    }
 
private:
    void apply_cutoff() {
        filter_.set_cutoff(static_cast<float>(
            std::min(cutoff_hz_ * brightness_, 0.49 * sample_rate_)));
    }
 
    double sample_rate_ = 44100.0;
    double level_ = 0.0;
    double cutoff_hz_ = 4000.0;
    double decay_ms_ = 2.0;
    double brightness_ = 1.0;
    DecayEnvelope64 envelope_;
    TptFilter filter_;
};

class NoiseLayer {
public:
    void prepare(double sample_rate) {
        envelope_.set_sample_rate(sample_rate);
        reset();
    }
 
    void reset() { envelope_.reset(); }
 
    void set_level(double level) {
        level_ = std::max(level, 0.0);
        if (level_ == 0.0) reset();
    }
    void set_decay_ms(double ms) {
        decay_ms_ = std::clamp(ms, 0.5, 4000.0);
        envelope_.set_decay_t60_ms(decay_ms_);
    }
 
    double level() const { return level_; }
 
    void trigger() {
        if (level_ <= 0.0) return;
        envelope_.set_attack_ms(0.2);
        envelope_.set_decay_t60_ms(decay_ms_);
        envelope_.trigger();
    }

    bool is_active() const { return level_ > 0.0 && envelope_.is_active(); }

    double process(double coloured) {
        if (!envelope_.is_active() || level_ <= 0.0) return 0.0;
        return coloured * envelope_.process() * level_;
    }
 
private:
    double level_ = 0.0;
    double decay_ms_ = 60.0;
    DecayEnvelope64 envelope_;
};

class ShellLayer {
public:
    void prepare(double sample_rate) {
        sample_rate_ = sample_rate > 0.0 ? sample_rate : sample_rate_;
        filter_.set_sample_rate(static_cast<float>(sample_rate_));
        filter_.set_mode(Svf::Mode::bandpass);
        apply();
        reset();
    }
 
    void reset() {
        filter_.reset();
        ring_level_ = 0.0;
    }
 
    void set_level(double level) {
        level_ = std::max(level, 0.0);
        if (level_ == 0.0) reset();
    }
    void set_frequency_hz(double hz) {
        frequency_hz_ = std::clamp(hz, 20.0, 20000.0);
        apply();
    }
    void set_resonance(double q) {
        resonance_ = std::clamp(q, 1.0, 30.0);
        apply();
    }
 
    double level() const { return level_; }
    double frequency_hz() const { return frequency_hz_; }
    double resonance() const { return resonance_; }
    bool is_ringing() const {
        return level_ > 0.0 && ring_level_ > kSilenceLevel;
    }
 
    double process(double excitation) {
        if (level_ <= 0.0) {
            ring_level_ = 0.0;
            return excitation;
        }
        const double resonance = static_cast<double>(
            filter_.process(static_cast<float>(excitation)));
        ring_level_ =
            std::max(std::fabs(resonance), ring_level_ * kLevelDecay);
        return excitation + level_ * resonance;
    }
 
private:
    void apply() {
        filter_.set_frequency(static_cast<float>(
            std::min(frequency_hz_, 0.49 * sample_rate_)));
        filter_.set_resonance(static_cast<float>(resonance_));
    }
 
    static constexpr double kSilenceLevel = 1.0e-6;
    static constexpr double kLevelDecay = 0.999;
 
    double sample_rate_ = 44100.0;
    double level_ = 0.0;
    double frequency_hz_ = 180.0;
    double resonance_ = 12.0;
    double ring_level_ = 0.0;
    Svf filter_;
};

class SubLayer {
public:
    void prepare(double sample_rate) {
        sample_rate_ = sample_rate > 0.0 ? sample_rate : sample_rate_;
        reset();
    }
 
    void reset() { phase_ = 0.0; }
 
    void set_level(double level) { level_ = std::max(level, 0.0); }
    double level() const { return level_; }
 
    void trigger() { phase_ = 0.0; }

    double process(double body_hz, double body_envelope) {
        if (level_ <= 0.0) return 0.0;
        phase_ += 0.5 * body_hz / sample_rate_;
        if (phase_ >= 1.0) phase_ -= std::floor(phase_);
        return std::sin(2.0 * 3.14159265358979323846 * phase_) * body_envelope * level_;
    }
 
private:
    double sample_rate_ = 44100.0;
    double level_ = 0.0;
    double phase_ = 0.0;
};
 
}  // namespace pulp::signal::drum