Loading...
Searching...
No Matches
MayaFlux::Nodes::Generator::Generator Class Referenceabstract
Base class for all signal and pattern generators in Maya Flux. More...
#include <Generator.hpp>
Inheritance diagram for MayaFlux::Nodes::Generator::Generator:
Collaboration diagram for MayaFlux::Nodes::Generator::Generator:
Public Member Functions | |
| 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 | printGraph ()=0 |
| Prints a visual representation of the generated pattern. | |
| virtual void | printCurrent ()=0 |
| Prints the current state and parameters of the generator. | |
| virtual void | update_context (double value) override |
| Updates the context object for callbacks. | |
| virtual void | set_frequency (float frequency) |
| Sets the generator's frequency. | |
| NodeContext & | get_last_context () override |
| Gets the last created context object. | |
| Public Member Functions inherited from MayaFlux::Nodes::Node | |
| virtual | ~Node ()=default |
| Virtual destructor for proper cleanup of derived classes. | |
| virtual double | process_sample (double input=0.)=0 |
| Processes a single data sample. | |
| virtual std::vector< double > | process_batch (unsigned int num_samples)=0 |
| Processes multiple samples at once. | |
| 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 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. | |
| virtual void | save_state ()=0 |
| Saves the node's current state for later restoration Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call. | |
| virtual void | restore_state ()=0 |
| Restores the node's state from the last save Recursively cascades through all connected modulator nodes Protected - only NodeSourceProcessor and NodeBuffer can call. | |
| 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 Attributes | |
| 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 | |
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 Member Functions inherited from MayaFlux::Nodes::Node | |
| virtual void | notify_tick (double value)=0 |
| Notifies all registered callbacks with the current context. | |
| virtual void | reset_processed_state_internal () |
| Resets the processed state of the node directly. | |
Detailed Description
Base class for all signal and pattern generators in Maya Flux.
Generators are specialized nodes that create numerical sequences from mathematical principles, rather than processing existing signals. They form the foundation of the computational graph by providing the initial patterns that other nodes can then transform, filter, or combine.
Unlike transformation nodes that modify input signals, generators typically:
- Create sequences based on mathematical formulas or algorithms
- Maintain internal state to track progression, phase, or other parameters
- Can operate autonomously without any input (though they may accept modulation inputs)
- Serve as the origin points in computational processing networks
Common types of generators include:
- Oscillators (sine, square, sawtooth, triangle waves)
- Stochastic generators (various probability distributions)
- Sample-based generators (playing back recorded sequences)
- Envelope generators (creating amplitude contours)
Generators integrate with the node graph system, allowing them to be:
- Connected to other nodes using operators like '>>' (chain)
- Combined with other nodes using operators like '+' (mix)
- Registered with a RootNode for processing
- Used as modulation sources for other generators or transformations
The Generator class extends the base Node interface with additional methods for visualization and analysis of the generated patterns.
Definition at line 110 of file Generator.hpp.
The documentation for this class was generated from the following files:
