modulation.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/timeline/item_id.hpp>
#include <pulp/timeline/parameter_target.hpp>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace pulp::timeline {


using ModulationTarget = ParameterTarget;

template <class... Fs> struct ModulationTargetCases : Fs... {
    using Fs::operator()...;
};
template <class... Fs> ModulationTargetCases(Fs...) -> ModulationTargetCases<Fs...>;

inline constexpr std::size_t kModulationTargetAlternativeCount =
    kParameterTargetAlternativeCount;

enum class ModulatorKind : std::uint8_t {
    Lfo,
    Envelope,
    Random,
    StepSequence,
};

constexpr std::string_view modulator_kind_name(ModulatorKind value) noexcept {
    switch (value) {
    case ModulatorKind::Lfo:
        return "lfo";
    case ModulatorKind::Envelope:
        return "envelope";
    case ModulatorKind::Random:
        return "random";
    case ModulatorKind::StepSequence:
        return "step_sequence";
    }
    return "lfo";
}

constexpr bool known_modulator_kind(ModulatorKind value) noexcept {
    switch (value) {
    case ModulatorKind::Lfo:
    case ModulatorKind::Envelope:
    case ModulatorKind::Random:
    case ModulatorKind::StepSequence:
        return true;
    }
    return false;
}

constexpr std::optional<ModulatorKind> modulator_kind_from_name(std::string_view name) noexcept {
    if (name == "lfo")
        return ModulatorKind::Lfo;
    if (name == "envelope")
        return ModulatorKind::Envelope;
    if (name == "random")
        return ModulatorKind::Random;
    if (name == "step_sequence")
        return ModulatorKind::StepSequence;
    return std::nullopt;
}

struct Modulator {
    ItemId id;
    ModulatorKind kind = ModulatorKind::Lfo;
    std::string name;

    bool valid() const noexcept {
        return id.valid();
    }
 
    bool operator==(const Modulator&) const = default;
};

struct MacroControl {
    ItemId id;
    std::string name;
    // Normalized authored position in [0, 1]. It is the macro's own value, not
    // any target parameter's: what each target receives is this scaled by the
    // depth of the route that reaches it.
    float value = 0.0f;

    bool valid() const noexcept {
        return id.valid();
    }
 
    bool operator==(const MacroControl&) const = default;
};

enum class ModulationSourceKind : std::uint8_t {
    Modulator,
    Macro,
};

constexpr std::string_view modulation_source_kind_name(ModulationSourceKind value) noexcept {
    switch (value) {
    case ModulationSourceKind::Modulator:
        return "modulator";
    case ModulationSourceKind::Macro:
        return "macro";
    }
    return "modulator";
}

constexpr std::optional<ModulationSourceKind>
modulation_source_kind_from_name(std::string_view name) noexcept {
    if (name == "modulator")
        return ModulationSourceKind::Modulator;
    if (name == "macro")
        return ModulationSourceKind::Macro;
    return std::nullopt;
}

struct ModulationSourceRef {
    ItemId id;
    ModulationSourceKind kind = ModulationSourceKind::Modulator;

    constexpr bool valid() const noexcept {
        return id.valid();
    }
 
    constexpr bool operator==(const ModulationSourceRef&) const = default;
};

inline constexpr float kMaximumModulationDepth = 1.0f;

struct ModulationRoute {
    ItemId id;
    ModulationSourceRef source;
    ModulationTarget target;
    // Signed scale in [-1, 1] applied to the source signal before it is added
    // to the target's base value. Negative inverts; zero is a connection that
    // is authored and silent, which is not the same as an absent one.
    float depth = 0.0f;
    // An authored bypass. A disabled route keeps its identity, depth, and
    // target so re-enabling it restores exactly what was there.
    bool enabled = true;

    constexpr bool valid() const noexcept {
        return id.valid();
    }
 
    bool operator==(const ModulationRoute&) const = default;
};

 
} // namespace pulp::timeline