MayaFlux::Nodes::Generator::Logic Class Reference

Digital signal processor implementing boolean logic operations. More...

#include <Logic.hpp>

Inheritance diagram for MayaFlux::Nodes::Generator::Logic:

Collaboration diagram for MayaFlux::Nodes::Generator::Logic:

Classes
struct	LogicCallback

Public Types
using	DirectFunction = std::function< bool(double)>
	Function type for stateless boolean evaluation.
using	MultiInputFunction = std::function< bool(const std::vector< double > &)>
	Function type for parallel input evaluation.
using	SequentialFunction = std::function< bool(std::span< bool >)>
	Function type for state-based evaluation.
using	TemporalFunction = std::function< bool(double, double)>
	Function type for time-dependent evaluation.

Public Member Functions
	Logic (double threshold=0.5)
	Constructs a Logic node with threshold quantization.
	Logic (LogicOperator op, double threshold=0.5)
	Constructs a Logic node with a specific boolean operator.
	Logic (DirectFunction function)
	Constructs a Logic node with a custom combinational function.
	Logic (MultiInputFunction function, size_t input_count)
	Constructs a Logic node for parallel input evaluation.
	Logic (SequentialFunction function, size_t history_size)
	Constructs a Logic node for state-based evaluation.
	Logic (TemporalFunction function)
	Constructs a Logic node for time-dependent evaluation.
virtual	~Logic ()=default
double	process_sample (double input=0.) override
	Processes a single input sample through the logic function.
std::vector< double >	process_batch (unsigned int num_samples) override
	Processes multiple samples in batch mode.
double	process_multi_input (const std::vector< double > &inputs)
	Processes multiple parallel inputs.
void	reset ()
	Resets internal state to initial conditions.
void	set_threshold (double threshold, bool create_default_direct_function=false)
	Sets the decision boundary for binary quantization.
void	set_hysteresis (double low_threshold, double high_threshold, bool create_default_direct_function=false)
	Configures noise-resistant binary quantization with memory.
void	set_edge_detection (EdgeType type, double threshold=0.5)
	Configures digital transition detection.
void	set_operator (LogicOperator op, bool create_default_direct_function=false)
	Sets the boolean operation to perform.
void	set_direct_function (DirectFunction function)
	Sets a custom combinational logic function.
void	set_multi_input_function (MultiInputFunction function, size_t input_count)
	Sets a custom parallel input evaluation function.
void	set_sequential_function (SequentialFunction function, size_t history_size)
	Sets a custom state-based evaluation function.
void	set_temporal_function (TemporalFunction function)
	Sets a custom time-dependent evaluation function.
void	set_initial_conditions (const std::vector< bool > &initial_values)
	Preloads the state history buffer.
void	set_input_node (const std::shared_ptr< Node > &input_node)
	Sets the input node to generate logic values from.
LogicMode	get_mode () const
	Gets the current computational model.
LogicOperator	get_operator () const
	Gets the current boolean operator.
double	get_threshold () const
	Gets the decision boundary for binary quantization.
size_t	get_history_size () const
	Gets the state history buffer capacity.
std::span< bool >	get_history ()
	Gets the current state history.
size_t	get_input_count () const
	Gets the number of parallel inputs expected.
bool	was_edge_detected () const
	Checks if a state transition was detected.
EdgeType	get_edge_type () const
	Gets the type of transitions being monitored.
void	printGraph () override
	Prints a visual representation of the logic function.
void	printCurrent () override
	Prints the current state and parameters.
void	on_tick (const NodeHook &callback) override
	Registers a callback for every generated sample.
void	on_tick_if (const NodeCondition &condition, const NodeHook &callback) override
	Registers a conditional callback for generated samples.
void	while_true (const NodeHook &callback)
	Registers a callback that executes continuously while output is true.
void	while_false (const NodeHook &callback)
	Registers a callback that executes continuously while output is false.
void	on_change_to (bool target_state, const NodeHook &callback)
	Registers a callback for when output changes to a specific state.
void	on_change (const NodeHook &callback)
	Registers a callback for any state change (true↔false)
bool	remove_hook (const NodeHook &callback) override
	Removes a previously registered callback.
bool	remove_conditional_hook (const NodeCondition &callback) override
	Removes a previously registered conditional callback.
void	remove_all_hooks () override
	Removes all registered callbacks.
void	remove_hooks_of_type (LogicEventType type)
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.
NodeContext &	get_last_context () override
	Retrieves the last created context object.
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 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	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.
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.

Protected Member Functions
void	update_context (double value) override
	Updates the context with the latest sample value.
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	add_input (double input, size_t index)
void	add_callback (const NodeHook &callback, LogicEventType type, const std::optional< NodeCondition > &condition=std::nullopt)
	Adds a callback to the list of all callbacks.
void	history_push (bool val)
std::span< bool >	history_linearized_view ()
std::span< double >	external_context_view (double input)

Private Attributes
LogicMode	m_mode
	Current processing mode.
LogicOperator	m_operator
	Current logic operator.
DirectFunction	m_direct_function
	Function for direct mode.
MultiInputFunction	m_multi_input_function
	Function for recursive/feedforward mode.
SequentialFunction	m_sequential_function
	Function for sequential mode.
TemporalFunction	m_temporal_function
	Function for temporal mode.
size_t	m_history_head {}
	Head index for the history ring buffer.
size_t	m_history_count {}
	Number of valid entries in the history buffer.
size_t	m_history_size
	Maximum size of the history buffer.
size_t	m_input_count
	Expected number of inputs for multi-input mode.
double	m_threshold
	Threshold for boolean conversion.
double	m_low_threshold
	Low threshold for hysteresis.
double	m_high_threshold
	High threshold for hysteresis.
EdgeType	m_edge_type
	Type of edge to detect.
bool	m_edge_detected {}
	Whether an edge was detected in the last processing.
bool	m_hysteresis_state {}
	State for hysteresis operator.
double	m_temporal_time {}
	Time tracking for temporal mode.
double	m_input {}
	Current input value for multi-input mode.
std::vector< double >	m_input_buffer
std::shared_ptr< Node >	m_input_node
	Input node for processing.
std::vector< uint8_t >	m_history_ring
	Ring buffer for history storage.
std::vector< uint8_t >	m_history_linear
	Linear view of history for easy access.
std::vector< LogicCallback >	m_all_callbacks
	Collection of all callback functions.
std::vector< uint8_t >	m_saved_history_ring
size_t	m_saved_history_head {}
size_t	m_saved_history_count {}
bool	m_saved_hysteresis_state {}
bool	m_saved_edge_detected {}
double	m_saved_temporal_time {}
double	m_saved_last_output {}
LogicContext	m_context
LogicContextGpu	m_context_gpu

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.
GeneratorContext	m_context { 0., m_frequency, m_amplitude, m_phase }
GeneratorContextGpu	m_context_gpu { 0., m_frequency, m_amplitude, m_phase, get_gpu_data_buffer() }
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

Detailed Description

Digital signal processor implementing boolean logic operations.

The Logic node transforms continuous signals into discrete binary outputs using configurable boolean operations. It supports multiple computational models:

• Combinational logic: Stateless evaluation based solely on current inputs
• Sequential logic: State-based evaluation using history of previous inputs
• Temporal logic: Time-dependent evaluation with timing constraints
• Multi-input logic: Parallel evaluation of multiple input signals

Applications include:

• Binary signal generation
• Event detection and triggering
• State machine implementation
• Digital pattern recognition
• Signal quantization and discretization
• Conditional processing chains

Definition at line 164 of file Logic.hpp.

---

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

• Logic.hpp
• Logic.cpp