Contains the node-based computational processing system components. More...

Namespaces
namespace	Filters

namespace	Generator

namespace	GpuSync

Classes
class	BinaryOpContext
	Specialized context for binary operation callbacks. More...

class	BinaryOpContextGpu
	GPU-compatible context for binary operation callbacks. More...

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

class	ChainNode
	Connects two nodes in series to form a processing chain. More...

class	GpuMatrixData
	GPU-uploadable 2D grid data interface. More...

class	GpuStructuredData
	GPU-uploadable structured data (arrays of POD structs) More...

class	GpuVectorData
	GPU-uploadable 1D array data interface. More...

class	ModalNetwork
	Network of resonant modes for modal synthesis. More...

class	Node
	Base interface for all computational processing nodes. More...

class	NodeContext
	Base context class for node callbacks. More...

class	NodeGraphManager
	Central manager for the computational processing node graph. More...

class	NodeNetwork
	Abstract base class for structured collections of nodes with defined relationships. More...

class	ParticleNetwork
	Network of particles with physics simulation. More...

class	RootNode
	Container for top-level nodes in a processing channel with multi-modal support. More...

Typedefs
using	TokenChannelProcessor = std::function< std::vector< double >(RootNode *, uint32_t)>

using	TokenSampleProcessor = std::function< double(RootNode *, uint32_t)>

using	NodeHook = std::function< void(NodeContext &)>
	Callback function type for node processing events.

using	NodeCondition = std::function< bool(NodeContext &)>
	Predicate function type for conditional callbacks.

Enumerations
enum class	ProcessingToken { AUDIO_RATE , VISUAL_RATE , CUSTOM_RATE }
	Enumerates the different processing domains for nodes. More...

Functions
std::shared_ptr< Node >	operator>> (std::shared_ptr< Node > lhs, std::shared_ptr< Node > rhs)
	Connects two nodes in series (pipeline operator)

std::shared_ptr< Node >	operator+ (std::shared_ptr< Node > lhs, std::shared_ptr< Node > rhs)
	Combines two nodes in parallel (addition operator)

std::shared_ptr< Node >	operator* (std::shared_ptr< Node > lhs, std::shared_ptr< Node > rhs)
	Multiplies the outputs of two nodes (multiplication operator)

void	operator* (std::shared_ptr< Node > node, double value)
	Sets the generator's amplitude.

bool	callback_exists (const std::vector< NodeHook > &callbacks, const NodeHook &callback)
	Checks if a callback function already exists in a collection.

bool	conditional_callback_exists (const std::vector< std::pair< NodeHook, NodeCondition > > &callbacks, const NodeCondition &callback)
	Checks if a condition function already exists in a collection of conditional callbacks.

bool	callback_pair_exists (const std::vector< std::pair< NodeHook, NodeCondition > > &callbacks, const NodeHook &callback, const NodeCondition &condition)
	Checks if a specific callback and condition pair already exists.

bool	safe_add_callback (std::vector< NodeHook > &callbacks, const NodeHook &callback)
	Safely adds a callback to a collection if it doesn't already exist.

bool	safe_add_conditional_callback (std::vector< std::pair< NodeHook, NodeCondition > > &callbacks, const NodeHook &callback, const NodeCondition &condition)
	Safely adds a conditional callback if it doesn't already exist.

bool	safe_remove_callback (std::vector< NodeHook > &callbacks, const NodeHook &callback)
	Safely removes a callback from a collection.

bool	safe_remove_conditional_callback (std::vector< std::pair< NodeHook, NodeCondition > > &callbacks, const NodeCondition &callback)
	Safely removes all conditional callbacks with a specific condition.

void	atomic_set_strong (std::atomic< Utils::NodeState > &flag, Utils::NodeState &expected, const Utils::NodeState &desired)
	Atomically sets a node state flag with strong memory ordering.

void	atomic_set_flag_strong (std::atomic< Utils::NodeState > &flag, const Utils::NodeState &desired)
	Atomically sets a node state flag to a specific value.

void	atomic_add_flag (std::atomic< Utils::NodeState > &state, Utils::NodeState flag)
	Atomically adds a flag to a node state.

void	atomic_remove_flag (std::atomic< Utils::NodeState > &state, Utils::NodeState flags)
	Atomically removes a flag from a node state.

void	atomic_set_flag_weak (std::atomic< Utils::NodeState > &flag, Utils::NodeState &expected, const Utils::NodeState &desired)
	Atomically sets a node state flag with weak memory ordering.

void	atomic_inc_modulator_count (std::atomic< uint32_t > &count, int amount)
	Atomically increments the modulator count by a specified amount.

void	atomic_dec_modulator_count (std::atomic< uint32_t > &count, int amount)
	Atomically decrements the modulator count by a specified amount.

void	try_reset_processed_state (std::shared_ptr< Node > node)
	Attempts to reset the processed state of a node.

std::vector< uint32_t >	get_active_channels (const std::shared_ptr< Nodes::Node > &node, uint32_t fallback_channel=0)
	Extracts active channel list from a node's channel mask.

std::vector< uint32_t >	get_active_channels (uint32_t channel_mask, uint32_t fallback_channel=0)
	Extracts active channel list from a channel mask.

Detailed Description

Contains the node-based computational processing system components.

The Nodes namespace provides a flexible, composable processing architecture based on the concept of interconnected computational nodes. Each node represents a discrete transformation unit that can be connected to other nodes to form complex processing networks and computational graphs.

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description