sequencer_ui_host.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <type_traits>
 
#include <pulp/timebase/loop_region.hpp>
#include <pulp/timebase/tick.hpp>
#include <pulp/timeline/item_id.hpp>

namespace pulp::timeline_editor {

enum class UiTransportState : std::uint8_t {
    Stopped,
    Playing,
    Scrubbing,
};

struct UiPlayhead {
    std::uint64_t program_generation = 0;
    std::uint64_t sequence = 0;
    std::uint64_t continuity_epoch = 0;
    timebase::TickPosition position{};
    timebase::LoopRegion loop{};
    UiTransportState state = UiTransportState::Stopped;
    double tempo_bpm = 120.0;

    constexpr bool moving() const noexcept {
        return state == UiTransportState::Playing || state == UiTransportState::Scrubbing;
    }
 
    constexpr bool operator==(const UiPlayhead&) const = default;
};
 
static_assert(std::is_trivially_copyable_v<UiPlayhead>,
              "UiPlayhead must be trivially copyable: a reading a view retains "
              "must survive the engine that produced it");

struct AuditionRequest {
    timeline::ItemId track{};
    timeline::ItemId item{};
    std::uint8_t pitch = 60;
    std::uint16_t velocity = 0xffff;
    std::uint8_t channel = 0;
    timebase::TickDuration duration{};
 
    constexpr bool operator==(const AuditionRequest&) const = default;
};
 
static_assert(std::is_trivially_copyable_v<AuditionRequest>,
              "AuditionRequest must be trivially copyable: it crosses to the "
              "host by value and may be queued to an audio thread");

struct AuditionHandle {
    std::uint64_t value = 0;
 
    constexpr bool valid() const noexcept { return value != 0; }
    constexpr bool operator==(const AuditionHandle&) const = default;
};
 
enum class AuditionStatus : std::uint8_t {
    Started,
    Unsupported,
    Busy,
    Rejected,
};

struct AuditionResult {
    AuditionStatus status = AuditionStatus::Unsupported;
    AuditionHandle handle{};
 
    constexpr bool operator==(const AuditionResult&) const = default;
};
 
enum class IntentStatus : std::uint8_t {
    Accepted,
    Deferred,
    Rejected,
};
 
struct IntentResult {
    IntentStatus status = IntentStatus::Deferred;
    std::uint64_t sequence = 0;
 
    constexpr bool operator==(const IntentResult&) const = default;
};

class SequencerUiHost {
  public:
    virtual ~SequencerUiHost() = default;

    virtual UiPlayhead playhead() const noexcept = 0;

    virtual AuditionResult begin_audition(const AuditionRequest& request) noexcept = 0;

    virtual void end_audition(AuditionHandle handle) noexcept = 0;
};

template <class Intent>
class SequencerUiHostT : public SequencerUiHost {
  public:
    using IntentType = Intent;

    virtual IntentResult submit_intent(const Intent& intent) noexcept = 0;
};
 
} // namespace pulp::timeline_editor