Combines the outputs of two nodes using a binary operation. More...

#include <NodeStructure.hpp>

Inheritance diagram for MayaFlux::Nodes::BinaryOpNode:

Collaboration diagram for MayaFlux::Nodes::BinaryOpNode:

Public Types
using	CombineFunc = std::function< double(double, double)>
	Function type for combining two node outputs.

Public Member Functions
	BinaryOpNode (const std::shared_ptr< Node > &lhs, const std::shared_ptr< Node > &rhs, CombineFunc func)
	Creates a new binary operation node.

void	initialize ()
	Initializes the binary operation node.

double	process_sample (double input=0.) override
	Processes a single sample through both nodes and combines the results.

std::vector< double >	process_batch (unsigned int num_samples) override
	Processes multiple samples through both nodes and combines the results.

void	reset_processed_state () override
	Resets the processed state of the node and any attached input nodes.

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.

bool	is_initialized () const

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 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	notify_tick (double value) override
	Notifies all registered callbacks about a new output value.

void	update_context (double value) override
	updates context object for callbacks

NodeContext &	get_last_context () override
	Retrieves the last created context object.

Protected Member Functions inherited from MayaFlux::Nodes::Node
virtual void	reset_processed_state_internal ()
	Resets the processed state of the node directly.

Private Attributes
std::shared_ptr< Node >	m_lhs
	The left-hand side node.

std::shared_ptr< Node >	m_rhs
	The right-hand side node.

CombineFunc	m_func
	The function used to combine the outputs of both nodes.

double	m_last_lhs_value {}
	The last output value from the left-hand side node.

double	m_last_rhs_value {}
	The last output value from the right-hand side node.

bool	m_is_initialized {}
	Flag indicating whether the binary operator has been properly initialized.

bool	m_state_saved {}

double	m_saved_last_lhs_value {}

double	m_saved_last_rhs_value {}

BinaryOpContext	m_context

BinaryOpContextGpu	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::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

Combines the outputs of two nodes using a binary operation.

The BinaryOpNode implements the Node interface and represents a combination of two nodes where both nodes process the same input, and their outputs are combined using a specified binary operation (like addition or multiplication). This is the implementation behind the '+' and '*' operators for nodes.

When processed, the BinaryOpNode:

Passes the input to both the left and right nodes
Takes the outputs from both nodes
Combines the outputs using the specified function
Returns the combined result

Definition at line 277 of file NodeStructure.hpp.

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

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description