MayaFlux::Nodes::Input::InputNode Class Reference

Abstract base class for nodes that receive external input. More...

#include <InputNode.hpp>

Inheritance diagram for MayaFlux::Nodes::Input::InputNode:

Collaboration diagram for MayaFlux::Nodes::Input::InputNode:

Public Member Functions
	InputNode (InputConfig config={})
	~InputNode () override=default
double	process_sample (double input=0.0) override
	Process a single sample.
std::vector< double >	process_batch (unsigned int num_samples) override
	Process a batch of samples.
virtual void	process_input (const Core::InputValue &value)
	Process an input value from a backend.
bool	has_new_input ()
	Check if new input has arrived since last check.
void	clear_input_flag ()
	Clear the new input flag without checking.
double	get_target_value () const
	Get the target value (before smoothing)
double	get_current_value () const
	Get the current smoothed value.
std::optional< Core::InputValue >	get_last_input () const
	Get the most recent raw InputValue.
std::vector< Core::InputValue >	get_input_history () const
	Get input history (thread-safe copy)
void	set_smoothing (SmoothingMode mode, double factor=0.1)
void	set_slew_rate (double rate)
const InputConfig &	get_config () const
NodeContext &	get_last_context () override
	Retrieves the last created context object.
void	on_input (const NodeHook &callback)
	Register callback for any input received.
void	on_value_change (const NodeHook &callback, double epsilon=0.0001)
	Register callback for value changes.
void	on_threshold_rising (double threshold, const NodeHook &callback)
	Register callback for threshold crossing (rising edge)
void	on_threshold_falling (double threshold, const NodeHook &callback)
	Register callback for threshold crossing (falling edge)
void	on_range_enter (double min, double max, const NodeHook &callback)
	Register callback for entering a value range.
void	on_range_exit (double min, double max, const NodeHook &callback)
	Register callback for exiting a value range.
void	on_button_press (const NodeHook &callback)
	Register callback for button press (0.0 → 1.0 transition)
void	on_button_release (const NodeHook &callback)
	Register callback for button release (1.0 → 0.0 transition)
void	while_in_range (double min, double max, const NodeHook &callback)
	Register callback while value is in range.
Public Member Functions inherited from MayaFlux::Nodes::Node
virtual	~Node ()=default
	Virtual destructor for proper cleanup of derived classes.
virtual void	on_tick (const NodeHook &callback)
	Registers a callback to be called on each tick.
virtual void	on_tick_if (const NodeCondition &condition, const NodeHook &callback)
	Registers a conditional callback.
virtual bool	remove_hook (const NodeHook &callback)
	Removes a previously registered callback.
virtual bool	remove_conditional_hook (const NodeCondition &callback)
	Removes a previously registered conditional callback.
virtual void	remove_all_hooks ()
	Removes all registered callbacks.
virtual void	reset_processed_state ()
	Resets the processed state of the node and any attached input nodes.
virtual double	get_last_output ()
	Retrieves the most recent output value produced by the node.
void	register_channel_usage (uint32_t channel_id)
	Mark the specificed channel as a processor/user.
void	unregister_channel_usage (uint32_t channel_id)
	Removes the specified channel from the usage tracking.
bool	is_used_by_channel (uint32_t channel_id) const
	Checks if the node is currently used by a specific channel.
void	request_reset_from_channel (uint32_t channel_id)
	Requests a reset of the processed state from a specific channel.
const std::atomic< uint32_t > &	get_channel_mask () const
	Retrieves the current bitmask of active channels using this node.
void	set_gpu_compatible (bool compatible)
	Sets whether the node is compatible with GPU processing.
bool	is_gpu_compatible () const
	Checks if the node supports GPU processing.
std::span< const float >	get_gpu_data_buffer () const
	Provides access to the GPU data buffer.
void	set_sample_rate (uint32_t sample_rate)
uint32_t	get_sample_rate () const
virtual void	save_state ()=0
	Saves the node's current state for later restoration Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call.
virtual void	restore_state ()=0
	Restores the node's state from the last save Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call.
bool	try_claim_snapshot_context (uint64_t context_id)
	Attempt to claim snapshot context for this processing cycle.
bool	is_in_snapshot_context (uint64_t context_id) const
	Check if currently in a snapshot context.
void	release_snapshot_context (uint64_t context_id)
	Release snapshot context.
bool	has_active_snapshot () const
	Check if node is currently being snapshotted by any context.
uint64_t	get_active_snapshot_context () const
	Get the active snapshot context ID.
void	add_buffer_reference ()
	Increments the buffer reference count This method is called when a new buffer starts using this node to ensure proper lifecycle management.
void	remove_buffer_reference ()
	Decrements the buffer reference count This method is called when a buffer stops using this node to ensure proper lifecycle management.
bool	mark_buffer_processed ()
	Marks the node as having been processed by a buffer.
void	request_buffer_reset ()
	Requests a reset of the buffer state.
bool	is_buffer_processed () const
	Checks if the buffer has been processed.
bool	is_in_network () const
	Sets whether the node is part of a NodeNetwork.
void	set_in_network (bool networked)
	Marks the node as being part of a NodeNetwork.
const RoutingState &	get_routing_state () const
	Retrieves the current routing state of the network.
RoutingState &	get_routing_state ()
	Retrieves the current routing state of the network (non-const)
bool	needs_channel_routing () const
	Checks if the network is currently in a routing transition phase.

Protected Member Functions
virtual double	extract_value (const Core::InputValue &value)
	Extract a scalar value from an InputValue.
void	update_context (double value) override
	Update context after processing.
void	notify_tick (double value) override
	Notify callbacks (minimal for InputNode)
Protected Member Functions inherited from MayaFlux::Nodes::Node
virtual void	reset_processed_state_internal ()
	Resets the processed state of the node directly.

Protected Attributes
InputConfig	m_config
InputContext	m_context
Protected Attributes inherited from MayaFlux::Nodes::Node
double	m_last_output { 0 }
	The most recent sample value generated by this oscillator.
bool	m_gpu_compatible {}
	Flag indicating if the node supports GPU processing This flag is set by derived classes to indicate whether the node can be processed on the GPU.
std::vector< float >	m_gpu_data_buffer
	GPU data buffer for context objects.
std::vector< NodeHook >	m_callbacks
	Collection of standard callback functions.
std::vector< std::pair< NodeHook, NodeCondition > >	m_conditional_callbacks
	Collection of conditional callback functions with their predicates.
bool	m_networked_node {}
	Flag indicating if the node is part of a NodeNetwork This flag is used to disable event firing when the node is managed within a NodeNetwork, preventing redundant or conflicting event notifications.
bool	m_state_saved {}
	tracks if the node's state has been saved by a snapshot operation
uint32_t	m_sample_rate { 48000 }
	Sample rate for audio processing, used for normalization.

Private Member Functions
double	apply_smoothing (double target, double current) const
void	add_input_callback (const NodeHook &callback, InputEventType event_type, std::optional< double > threshold={}, std::optional< std::pair< double, double > > range={}, std::optional< NodeCondition > condition={})

Private Attributes
std::atomic< double >	m_target_value { 0.0 }
std::atomic< double >	m_current_value { 0.0 }
std::atomic< bool >	m_has_new_input { false }
double	m_previous_value {}
bool	m_was_in_range {}
std::atomic< uint32_t >	m_last_device_id { 0 }
Core::InputType	m_last_source_type { Core::InputType::HID }
std::vector< InputCallback >	m_input_callbacks
Memory::LockFreeQueue< Core::InputValue, 64 >	m_input_history

Additional Inherited Members
Public Attributes inherited from MayaFlux::Nodes::Node
bool	m_fire_events_during_snapshot = false
	Internal flag controlling whether notify_tick fires during state snapshots Default: false (events don't fire during isolated buffer processing) Can be exposed in future if needed via concrete implementation in parent.
std::atomic< NodeState >	m_state { NodeState::INACTIVE }
	Atomic state flag tracking the node's processing status.
std::atomic< uint32_t >	m_modulator_count { 0 }
	Counter tracking how many other nodes are using this node as a modulator.

Detailed Description

Abstract base class for nodes that receive external input.

InputNode follows a similar pattern to GpuSync: it bridges async external data (input events) with the synchronous node processing system.

Key characteristics:

• on_input() receives async data from InputSubsystem (like compute_frame produces data)
• process_sample() returns smoothed values for downstream consumption
• needs_processing() indicates if new input has arrived (like needs_gpu_update)
• Minimal callback overhead (input IS the event)

Unlike audio Generators that produce continuous streams, InputNodes:

• Are event-driven (data arrives sporadically)
• Apply smoothing to convert discrete events to continuous signals
• Don't drive timing (they respond to external timing)

Derived classes implement:

• extract_value(): Convert InputValue to scalar
• Optionally override on_input() for specialized handling

Definition at line 113 of file InputNode.hpp.

---

The documentation for this class was generated from the following files:

• InputNode.hpp
• InputNode.cpp