Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Public Attributes | Static Public Attributes | Friends | List of all members
Nodes::ValueLooper::Node Struct Reference
Inheritance diagram for Nodes::ValueLooper::Node:
Nodes::Looper::looper_node< Node >

Classes

struct  ins
 
struct  ui
 
struct  worker_t
 

Public Types

using LoopMode = Looper::LoopMode
 
using Passthrough = Looper::Passthrough
 
- Public Types inherited from Nodes::Looper::looper_node< Node >
using LoopMode = Looper::LoopMode
 
using tick = ossia::token_request
 

Public Member Functions

 halp_meta (name, "Looper (values)") halp_meta(c_name
 
value_looper halp_meta (category, "Control/Mappings") halp_meta(author
 
value_looper ossia score halp_meta (manual_url, "https://ossia.io/score-docs/processes/value-looper.html") halp_meta(description
 
value_looper ossia score Loop a stream of values in impulses fired where they and turn the loop into automations of the timeline halp_meta (uuid, "399796c5-9e86-4a00-8671-3e759ad6fb33")
 
 halp_meta (recommended_height, 200)
 
 halp_flag (process_exec)
 
void process_message (const Looper::erase_request &r)
 From the view: applied at the start of the next tick.
 
void prepare (halp::setup)
 
void stop ()
 
 ~Node ()
 
int64_t looper_run (int64_t start, int64_t length)
 
void looper_trim_recording (int64_t frames)
 
void operator() (const tick &tk)
 
- Public Member Functions inherited from Nodes::Looper::looper_node< Node >
void loop_arrived () noexcept
 A value came in on Mode.
 
void looper_close_take (const ossia::token_request &tk, LoopMode mode, bool ended_by_postaction)
 
int64_t looper_trim_extension (int64_t max_frames)
 
void looper_rephase (const ossia::token_request &tk)
 
int64_t looper_frames_to_end () const noexcept
 An extending overdub grows the loop at its end instead of reaching it.
 
Looper::loop_period looper_period (const ossia::token_request &tk) const noexcept
 
void looper_point ()
 
int looper_passes () const noexcept
 
int looper_pass_of (uint32_t id) const noexcept
 
bool looper_muted (int pass) const noexcept
 
void looper_set_muted (int pass, bool muted)
 
void looper_mute (int pass, int muted=-1)
 
void looper_erase (int pass)
 
void looper_begin_actions () noexcept
 
void looper_end_actions () noexcept
 

Public Attributes

value_looper ossia score Loop a stream of values in passes: numbers and vectors held as a " "curve
 
value_looper ossia score Loop a stream of values in impulses fired where they came
 
struct Nodes::ValueLooper::Node::ins inputs
 
struct { 
 
   ossia_port<"out", ossia::value_port >   values 
 
      phase 
 
} outputs 
 
struct Nodes::ValueLooper::Node::worker_t worker
 
std::function< void(Looper::view_message)> send_message
 
std::function< void(Looper::view_message)> send_message_from_worker
 
const score::DocumentContext * ossia_document_context {}
 
ossia::exec_state_facade ossia_state
 
Looper::value_loop loop
 
std::shared_ptr< Looper::take_writer > writer
 
std::shared_ptr< Looper::value_export > export_data
 
std::shared_ptr< Looper::value_stop_take > stop_take
 
- Public Attributes inherited from Nodes::Looper::looper_node< Node >
Looper::transport transport
 

Static Public Attributes

static constexpr int max_keys = 1
 Keys of the values looped: one stream for now.
 
static constexpr double input_hold_seconds = 0.2
 
static constexpr double max_loop_seconds = 3600.
 Longest loop an extending overdub makes, as the audio looper's longest.
 

Friends

struct Looper::looper_node< Node >
 

Additional Inherited Members

- Protected Member Functions inherited from Nodes::Looper::looper_node< Node >
bool pass_pending () const noexcept
 
bool pass_open () const noexcept
 A pass is open in the stack.
 
bool may_redo () const noexcept
 
Looper::undo_mark undo_mark () const noexcept
 Where the passes and the actions undo goes back through are.
 
void material_arriving ()
 
void pass_advanced (double frames, bool backwards)
 The pass being taken in went over frames more frames of the loop.
 
double pass_progress () const noexcept
 The frames the pass being taken in went over.
 
void passes_changing ()
 The passes, or what is heard of them, are about to change.
 
Node & self () noexcept
 
const Node & self () const noexcept
 
auto & stack () noexcept
 
const auto & stack () const noexcept
 
void view_request (const Looper::erase_request &r) noexcept
 From the view: applied at the start of the next tick.
 
void run_tick (const tick &tk)
 
void apply_buttons ()
 
void follow_merges ()
 
void clear_loop ()
 
void drop_taken_pass ()
 
void undo_pass ()
 
void drop_top_pass ()
 The newest pass goes, as undo hides it, and redo does not bring it back.
 
void erase_pass (int pass)
 
void mute_pass (int pass, int muted=-1)
 Mutes a pass, or lets it be heard: muted says which, or it toggles.
 
int make_room ()
 
void begin_pass (int64_t start)
 
void begin_pass_now (int64_t start)
 
void close_pass (bool cycle=false)
 
void merge_extra_pass ()
 
void capture (const tick &tk)
 
void capture_layer (const tick &tk, int64_t now, int64_t end)
 
void stop_score ()
 
double rounds_since_made (const ossia::token_request &tk) const noexcept
 
void run_export ()
 
void take_written (int slot, int number, bool ok, bool alone)
 
bool last_take_whole () const noexcept
 The last take has the mix and every pass as they are now.
 
void prepare_stop_notice (Looper::stop_take_notice &n, double date)
 
int claim_take_slot () noexcept
 
bool view_due (int64_t frames) noexcept
 Whether the view is due a message: some 30 a second.
 
void fill_view (Looper::view_message &v) const noexcept
 
bool placeable_take () const noexcept
 
- Static Protected Member Functions inherited from Nodes::Looper::looper_node< Node >
static constexpr bool lazy_passes () noexcept
 
static uint64_t next_looper_id () noexcept
 
- Protected Attributes inherited from Nodes::Looper::looper_node< Node >
double m_rate {48000.}
 
double m_tempo {120.}
 
ossia::time_signature m_signature {4, 4}
 
LoopMode m_mode {LoopMode::Stop}
 The mode asked for, as the transport takes it up.
 
Looper::loop_input m_loop
 What came in on Mode, and what it shows.
 
Looper::switches m_switches
 
double m_speed {1.}
 The playhead goes at m_speed, backwards when m_reverse is set.
 
bool m_reverse {}
 
Looper::transport::timeline_point m_origin {}
 
double m_loop_tempo {120.}
 Tempo the loop was recorded at: the loop keeps its own speed.
 
int64_t m_extend_unit {}
 
bool m_extended {}
 
bool m_cycle_pending {}
 
bool m_export_pending {}
 
bool m_writing {}
 
double m_export_date {}
 
double m_job_date {}
 
double m_export_tempo {120.}
 
ossia::time_signature m_export_signature {4, 4}
 
int m_export_item {}
 
int m_export_layers {}
 
bool m_export_mix {}
 
int m_export_number {}
 
int m_export_slot {}
 
halp::clip_stretch m_job_stretch {}
 
halp::clip_stretch m_stop_stretch {}
 
int m_takes_written {}
 
int m_take_request {}
 
int m_job_request {}
 
Looper::erase_request m_part_request {.pass = -1, .layers = -1}
 
bool m_job_part {}
 
int m_export_first {}
 
int m_version {}
 
int m_job_version {}
 
bool m_pass_pending {}
 
int64_t m_pending_start {}
 
int64_t m_pending_length {}
 
double m_pending_progress {}
 
bool m_pending_backwards {}
 
int m_next_take_slot {}
 
int64_t m_view_countdown {}
 
uint64_t m_id {next_looper_id()}
 Tells this looper's messages from another's, and counts its stops.
 
int m_stops {}
 
Looper::view_message m_view {}
 
std::array< Looper::erase_request, 16 > m_erase_requests {}
 The m and x the view sent since the last tick.
 
int m_erase_count {}
 

Constructor & Destructor Documentation

◆ ~Node()

Nodes::ValueLooper::Node::~Node ( )
inline

The score stopping takes the looper away before that tick: it stops as it goes, and leaves its take.

Member Function Documentation

◆ stop()

void Nodes::ValueLooper::Node::stop ( )
inline

The score stops: the take it leaves is written on the next tick, which a box ending still runs.

Member Data Documentation

◆ input_hold_seconds

constexpr double Nodes::ValueLooper::Node::input_hold_seconds = 0.2
staticconstexpr

A value the input sends wins over the loop's for this long, when it is heard: while it moves, the input is what goes out.

◆ send_message_from_worker

std::function<void(Looper::view_message)> Nodes::ValueLooper::Node::send_message_from_worker

What the take the score's stop leaves is told to the views with, from its worker.

◆ stop_take

std::shared_ptr<Looper::value_stop_take> Nodes::ValueLooper::Node::stop_take

What the take the score's stop leaves is made of: the node may be gone before it is written.

The documentation for this struct was generated from the following file: