MayaFlux::Nodes::Generator::Impulse Class Reference

Impulse generator node. More...

#include <Impulse.hpp>

Inheritance diagram for MayaFlux::Nodes::Generator::Impulse:

Collaboration diagram for MayaFlux::Nodes::Generator::Impulse:

Public Member Functions
	Impulse (float frequency=1, double amplitude=1, float offset=0)
	Basic constructor with fixed parameters.
	Impulse (const std::shared_ptr< Node > &frequency_modulator, float frequency=1, double amplitude=1, float offset=0)
	Constructor with frequency modulation.
	Impulse (float frequency, const std::shared_ptr< Node > &amplitude_modulator, double amplitude=1, float offset=0)
	Constructor with amplitude modulation.
	Impulse (const std::shared_ptr< Node > &frequency_modulator, const std::shared_ptr< Node > &amplitude_modulator, float frequency=1, double amplitude=1, float offset=0)
	Constructor with both frequency and amplitude modulation.
	~Impulse () override=default
	Virtual destructor.
double	process_sample (double input=0.) override
	Processes a single input sample and generates an impulse sample.
std::vector< double >	process_batch (unsigned int num_samples) override
	Processes multiple samples at once.
void	printGraph () override
	Prints a visual representation of the impulse train.
void	printCurrent () override
	Prints the current parameters of the impulse generator.
void	set_frequency (float frequency) override
	Sets the generator's frequency.
float	get_frequency () const
	Gets the current base frequency.
void	set_params (float frequency, double amplitude, float offset)
	Sets all basic parameters at once.
void	set_frequency_modulator (const std::shared_ptr< Node > &modulator)
	Sets a node to modulate the generator's frequency.
void	set_amplitude_modulator (const std::shared_ptr< Node > &modulator)
	Sets a node to modulate the generator's amplitude.
void	clear_modulators ()
	Removes all modulation connections.
void	reset (float frequency=1, float amplitude=1.0F, float offset=0)
	Resets the generator's phase and parameters.
void	on_impulse (const NodeHook &callback)
	Registers a callback for every impulse.
bool	remove_hook (const NodeHook &callback) override
	Removes a previously registered callback.
void	remove_all_hooks () override
	Removes all registered callbacks.
void	save_state () override
	Saves the node's current state for later restoration Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call.
void	restore_state () override
	Restores the node's state from the last save Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call.
Public Member Functions inherited from MayaFlux::Nodes::Generator::Generator
virtual	~Generator ()=default
	Virtual destructor for proper cleanup.
virtual void	set_amplitude (double amplitude)
	Sets the generator's amplitude.
virtual double	get_amplitude () const
	Gets the current base amplitude.
virtual void	enable_mock_process (bool mock_process)
	Allows RootNode to process the Generator without using the processed sample.
virtual bool	should_mock_process () const
	Checks if the generator should mock process.
virtual std::unique_ptr< NodeContext >	create_context (double value) override
	Creates a context object for callbacks.
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 NodeHook &callback, const NodeCondition &condition)
	Registers a conditional callback.
virtual bool	remove_conditional_hook (const NodeCondition &callback)
	Removes a previously registered conditional callback.
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.
NodeContext &	get_last_context ()
	Retrieves the last created context object.
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.

Protected Member Functions
void	notify_tick (double value) override
	Notifies all registered callbacks about a new sample.
Protected Member Functions inherited from MayaFlux::Nodes::Node
virtual void	reset_processed_state_internal ()
	Resets the processed state of the node directly.

Private Member Functions
void	update_phase_increment (double frequency)
	Updates the phase increment based on a new frequency.

Private Attributes
double	m_phase_inc {}
	Phase increment per sample.
float	m_offset
	DC offset added to the output.
std::shared_ptr< Node >	m_frequency_modulator
	Node that modulates the frequency.
std::shared_ptr< Node >	m_amplitude_modulator
	Node that modulates the amplitude.
std::vector< NodeHook >	m_impulse_callbacks
	Collection of impulse-specific callback functions.
bool	m_impulse_occurred
double	m_saved_phase {}
float	m_saved_frequency {}
float	m_saved_offset {}
double	m_saved_phase_inc {}
double	m_saved_last_output {}
bool	m_state_saved {}

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< Utils::NodeState >	m_state { Utils::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.
Protected Attributes inherited from MayaFlux::Nodes::Generator::Generator
double	m_amplitude { 1.0 }
	Base amplitude of the generator.
float	m_frequency { 440.0F }
	Base frequency of the generator.
double	m_phase {}
	Current phase of the generator.
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::unique_ptr< NodeContext >	m_last_context
	The last context object created for callbacks.
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.

Detailed Description

Impulse generator node.

The Impulse class generates a single spike followed by zeros, which is a fundamental signal used in digital signal processing. It produces a value of 1.0 (or specified amplitude) at specified intervals, and 0.0 elsewhere.

Key features:

• Configurable frequency, amplitude, and DC offset
• Support for frequency modulation (changing impulse rate)
• Support for amplitude modulation (changing impulse height)
• Automatic registration with the node graph manager (optional)
• Precise timing control for impulse generation

Impulse generators are used extensively in audio and signal processing for:

• Triggering events at specific intervals
• Testing system responses (impulse response)
• Creating click trains and metronome-like signals
• Serving as the basis for more complex event-based generators
• Synchronization signals for other generators

The implementation uses a phase accumulation approach similar to other oscillators but only outputs a non-zero value at the beginning of each cycle.

Definition at line 32 of file Impulse.hpp.

---

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

• Impulse.hpp
• Impulse.cpp