MayaFlux::Nodes::Generator::Polynomial Class Reference

Generator that produces values based on polynomial functions. More...

#include <Polynomial.hpp>

Inheritance diagram for MayaFlux::Nodes::Generator::Polynomial:

Collaboration diagram for MayaFlux::Nodes::Generator::Polynomial:

Public Types
using	DirectFunction = std::function< double(double)>
	Function type for direct polynomial evaluation.
using	BufferFunction = std::function< double(const std::deque< double > &)>
	Function type for recursive/feedforward polynomial evaluation.

Public Member Functions
	Polynomial (const std::vector< double > &coefficients)
	Constructs a Polynomial generator in direct mode with coefficient-based definition.
	Polynomial (DirectFunction function)
	Constructs a Polynomial generator in direct mode with a custom function.
	Polynomial (BufferFunction function, PolynomialMode mode, size_t buffer_size)
	Constructs a Polynomial generator in recursive or feedforward mode.
	~Polynomial () override=default
double	process_sample (double input=0.) override
	Processes a single sample.
std::vector< double >	process_batch (unsigned int num_samples) override
	Processes multiple samples at once.
void	reset ()
	Resets the generator to its initial state.
void	set_coefficients (const std::vector< double > &coefficients)
	Sets the polynomial coefficients (for direct mode)
void	set_direct_function (DirectFunction function)
	Sets a custom direct function.
void	set_buffer_function (BufferFunction function, PolynomialMode mode, size_t buffer_size)
	Sets a custom buffer function.
void	set_initial_conditions (const std::vector< double > &initial_values)
	Sets initial conditions for recursive mode.
DirectFunction	create_polynomial_function (const std::vector< double > &coefficients)
	Creates a polynomial function from coefficients.
void	set_input_node (const std::shared_ptr< Node > &input_node)
	Sets the input node to generate polynomial values from.
PolynomialMode	get_mode () const
	Gets the current polynomial mode.
size_t	get_buffer_size () const
	Gets the buffer size.
const std::vector< double > &	get_coefficients () const
	Gets the polynomial coefficients.
const std::deque< double > &	get_input_buffer () const
	Gets the input buffer.
const std::deque< double > &	get_output_buffer () const
	Gets the output buffer.
void	printGraph () override
	Prints a visual representation of the polynomial function.
void	printCurrent () override
	Prints the current state and parameters.
void	set_amplitude (double amplitude) override
	Sets the scaling factor for the output values.
double	get_amplitude () const override
	Gets the current amplitude scaling factor.
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.
void	set_buffer_context (std::span< double > buffer_view)
	Uses an external buffer context for processing.
void	clear_buffer_context ()
	Clear external buffer context, resume internal accumulation.
bool	using_external_context () const
Public Member Functions inherited from MayaFlux::Nodes::Generator::Generator
virtual	~Generator ()=default
	Virtual destructor for proper cleanup.
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 void	set_frequency (float frequency)
	Sets the generator's frequency.
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_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.
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
std::unique_ptr< NodeContext >	create_context (double value) override
	Creates a context object for callbacks.
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
std::deque< double >	build_processing_buffer (double input, bool use_output_buffer)
	Builds buffer from external context or internal accumulation.

Private Attributes
PolynomialMode	m_mode
	Converts coefficient vector to a polynomial function.
DirectFunction	m_direct_function
	Function for direct mode.
BufferFunction	m_buffer_function
	Function for recursive/feedforward mode.
std::vector< double >	m_coefficients
	Polynomial coefficients (if using coefficient-based definition)
std::deque< double >	m_input_buffer
	Buffer of input values for feedforward mode.
std::deque< double >	m_output_buffer
	Buffer of output values for recursive mode.
std::span< double >	m_external_buffer_context
size_t	m_buffer_size
	Maximum size of the buffers.
double	m_scale_factor
	Scaling factor for output.
std::shared_ptr< Node >	m_input_node
	Input node for processing.
size_t	m_current_buffer_position {}
std::deque< double >	m_saved_input_buffer
	Buffer of input values for feedforward mode.
std::deque< double >	m_saved_output_buffer
	Buffer of output values for recursive mode.
double	m_saved_last_output {}
bool	m_state_saved {}
bool	m_use_external_context {}

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

Generator that produces values based on polynomial functions.

The Polynomial generator creates a signal based on mathematical functions that can operate in different modes:

• Direct mode: evaluates f(x) where x is the current phase or input
• Recursive mode: evaluates using current and previous outputs
• Feedforward mode: evaluates using current and previous inputs

This flexible approach allows implementing various types of polynomial equations, difference equations, and recurrence relations.

Definition at line 114 of file Polynomial.hpp.

---

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

• Polynomial.hpp
• Polynomial.cpp