Loading...
Searching...
No Matches
MayaFlux::Nodes::GpuSync::SDFNode Class Reference
MeshWriterNode that extracts a TRIANGLE_LIST isosurface from a Kinesis::SpatialField each frame via marching cubes. More...
#include <SDFNode.hpp>
Inheritance diagram for MayaFlux::Nodes::GpuSync::SDFNode: Collaboration diagram for MayaFlux::Nodes::GpuSync::SDFNode:Public Member Functions | |
| void | compute_frame () override |
| Re-extract the isosurface if dirty, then upload via parent. | |
| SDFNode (Kinesis::SpatialField field, const glm::vec3 &bounds_min, const glm::vec3 &bounds_max, uint32_t res_x, uint32_t res_y, uint32_t res_z, float iso_level=0.0F) | |
| Construct and evaluate the initial isosurface. | |
| void | set_bounds (const glm::vec3 &bounds_min, const glm::vec3 &bounds_max) |
| Replace the evaluation volume and mark dirty. | |
| void | set_field (Kinesis::SpatialField field) |
| Replace the scalar field and mark dirty. | |
| void | set_iso_level (float iso_level) |
| Replace the iso_level threshold and mark dirty. | |
| void | set_resolution (uint32_t res_x, uint32_t res_y, uint32_t res_z) |
| Replace the grid resolution and mark dirty. | |
| ~SDFNode () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::GpuSync::MeshWriterNode | |
| void | clear_mesh () |
| size_t | get_mesh_face_count () const |
| const std::vector< uint32_t > & | get_mesh_indices () const |
| size_t | get_mesh_vertex_count () const |
| const std::vector< MeshVertex > & | get_mesh_vertices () const |
| Portal::Graphics::PrimitiveTopology | get_primitive_topology () const override |
| Get primitive topology for rendering. | |
| MeshWriterNode (size_t initial_vertex_capacity=1024) | |
| void | set_mesh (const Kakshya::MeshData &data) |
| Replace all vertex and index data from a MeshData owner. | |
| void | set_mesh (std::span< const MeshVertex > vertices, std::span< const uint32_t > indices) |
| Replace all vertex and index data atomically. | |
| void | set_mesh_indices (std::span< const uint32_t > indices) |
| Replace index array only; vertex array is unchanged. | |
| void | set_mesh_vertices (std::span< const MeshVertex > vertices) |
| Replace vertex array only; index array is unchanged. | |
| Public Member Functions inherited from MayaFlux::Nodes::GpuSync::GeometryWriterNode | |
| void | clear () |
| Clear vertex buffer and reset count. | |
| void | clear_and_resize (uint32_t vertex_count) |
| Clear vertex buffer and resize to specified count. | |
| void | clear_gpu_update_flag () override |
| Clear the dirty flag after GPU upload completes. | |
| void | clear_layout_update_flag () |
| Clear layout update flag. | |
| GeometryWriterNode (uint32_t initial_capacity=1024) | |
| Constructor. | |
| uint32_t | get_index_count () const |
| Get number of indices in index buffer. | |
| std::span< const uint32_t > | get_index_data () const |
| Get raw index buffer data. | |
| NodeContext & | get_last_context () override |
| Retrieves the last created context object. | |
| std::span< const uint8_t > | get_vertex (uint32_t vertex_index) const |
| Get a single vertex by index. | |
| size_t | get_vertex_buffer_size_bytes () const |
| Get vertex buffer size in bytes. | |
| uint32_t | get_vertex_count () const |
| Get number of vertices. | |
| std::span< const uint8_t > | get_vertex_data () const |
| Get raw vertex buffer data. | |
| std::optional< Kakshya::VertexLayout > | get_vertex_layout () const |
| Get cached vertex layout. | |
| size_t | get_vertex_stride () const |
| Get stride (bytes per vertex) | |
| template<typename T > | |
| T | get_vertex_typed (uint32_t index) const |
| Get a single vertex by index as typed data. | |
| bool | has_indices () const |
| Check if index buffer has been set. | |
| void | mark_vertex_data_dirty (bool state) |
| Set vertex data dirty flag. | |
| bool | needs_gpu_update () const override |
| Check if vertex data or layout changed since last GPU sync. | |
| bool | needs_layout_update () const |
| Check if layout needs update. | |
| bool | needs_vertex_data_update () const |
| Check if vertex data has changed since last GPU sync. | |
| std::vector< double > | process_batch (unsigned int num_samples) override |
| Process batch for geometry generation. | |
| void | resize_vertex_buffer (uint32_t vertex_count, bool preserve_data=false) |
| Resize vertex buffer to hold specified number of vertices. | |
| void | restore_state () override |
| Restore saved geometry state. | |
| void | save_state () override |
| Save current geometry state. | |
| void | set_indices (std::span< const uint32_t > indices) |
| Set index buffer for indexed drawing. | |
| void | set_vertex (uint32_t vertex_index, const void *data, size_t size_bytes) |
| Set a single vertex by index. | |
| void | set_vertex_data (const void *data, size_t size_bytes) |
| Copy raw vertex data into buffer. | |
| void | set_vertex_layout (const Kakshya::VertexLayout &layout) |
| Set cached vertex layout. | |
| void | set_vertex_stride (size_t stride) |
| Set vertex stride (bytes per vertex) | |
| template<typename T > | |
| void | set_vertex_typed (uint32_t index, const T &vertex) |
| Set a single vertex by index from typed data. | |
| template<typename T > | |
| void | set_vertices (std::span< const T > vertices) |
| Set multiple vertices from typed array. | |
| void | update_context (double value) override |
| Updates the context object with the current node state. | |
| ~GeometryWriterNode () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::GpuSync::GpuSync | |
| std::vector< double > | process_batch (unsigned int num_samples) override |
| Batch processing for GPU nodes. | |
| double | process_sample (double) override |
| Single sample processing hook. | |
| ~GpuSync () override=default | |
| Public Member Functions inherited from MayaFlux::Nodes::Node | |
| 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. | |
| uint64_t | get_active_snapshot_context () const |
| Get the active snapshot context ID. | |
| const std::atomic< uint32_t > & | get_channel_mask () const |
| Retrieves the current bitmask of active channels using this node. | |
| uint32_t | get_frame_rate () const |
| std::span< const float > | get_gpu_data_buffer () const |
| Provides access to the GPU data buffer. | |
| virtual double | get_last_output () |
| Retrieves the most recent output value produced by the node. | |
| std::vector< ModulatorTree > | get_modulator_tree () const |
| Returns the full modulator tree rooted at this node. | |
| virtual std::vector< std::pair< ModulatorRole, std::shared_ptr< Node > > > | get_modulators () const |
| Returns direct modulator nodes and their roles. | |
| RoutingState & | get_routing_state () |
| Retrieves the current routing state of the network (non-const) | |
| const RoutingState & | get_routing_state () const |
| Retrieves the current routing state of the network. | |
| uint32_t | get_sample_rate () const |
| bool | has_active_snapshot () const |
| Check if node is currently being snapshotted by any context. | |
| bool | has_capability (NodeCapability cap) const |
| Query a single capability. | |
| bool | is_buffer_processed () const |
| Checks if the buffer has been processed. | |
| bool | is_gpu_compatible () const |
| Checks if the node supports GPU processing. | |
| bool | is_in_network () const |
| Sets whether the node is part of a NodeNetwork. | |
| bool | is_in_snapshot_context (uint64_t context_id) const |
| Check if currently in a snapshot context. | |
| bool | is_used_by_channel (uint32_t channel_id) const |
| Checks if the node is currently used by a specific channel. | |
| bool | mark_buffer_processed () |
| Marks the node as having been processed by a buffer. | |
| bool | needs_channel_routing () const |
| Checks if the network is currently in a routing transition phase. | |
| virtual uint8_t | node_capabilities () const |
| Declare which data shapes this node's context can produce. | |
| 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. | |
| void | register_channel_usage (uint32_t channel_id) |
| Mark the specificed channel as a processor/user. | |
| void | release_snapshot_context (uint64_t context_id) |
| Release snapshot context. | |
| virtual void | remove_all_hooks () |
| Removes all registered callbacks. | |
| 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. | |
| virtual bool | remove_conditional_hook (const NodeCondition &callback) |
| Removes a previously registered conditional callback. | |
| virtual bool | remove_hook (const NodeHook &callback) |
| Removes a previously registered callback. | |
| void | request_buffer_reset () |
| Requests a reset of the buffer state. | |
| void | request_reset_from_channel (uint32_t channel_id) |
| Requests a reset of the processed state from a specific channel. | |
| virtual void | reset_processed_state () |
| Resets the processed state of the node and any attached input nodes. | |
| void | set_frame_rate (uint32_t frame_rate) |
| virtual void | set_gpu_compatible (bool compatible) |
| Sets whether the node is compatible with GPU processing. | |
| void | set_in_network (bool networked) |
| Marks the node as being part of a NodeNetwork. | |
| void | set_sample_rate (uint32_t sample_rate) |
| bool | try_claim_snapshot_context (uint64_t context_id) |
| Attempt to claim snapshot context for this processing cycle. | |
| void | unregister_channel_usage (uint32_t channel_id) |
| Removes the specified channel from the usage tracking. | |
| virtual | ~Node ()=default |
| Virtual destructor for proper cleanup of derived classes. | |
Private Member Functions | |
| void | rebuild () |
Private Attributes | |
| glm::vec3 | m_bounds_max |
| glm::vec3 | m_bounds_min |
| bool | m_dirty { false } |
| Kinesis::SpatialField | m_field |
| float | m_iso_level |
| uint32_t | m_res_x |
| uint32_t | m_res_y |
| uint32_t | m_res_z |
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< uint32_t > | m_modulator_count { 0 } |
| Counter tracking how many other nodes are using this node as a modulator. | |
| std::atomic< NodeState > | m_state { NodeState::INACTIVE } |
| Atomic state flag tracking the node's processing status. | |
| Protected Member Functions inherited from MayaFlux::Nodes::GpuSync::GpuSync | |
| void | notify_tick (double) override |
| GPU sync nodes don't emit tick callbacks. | |
| Protected Member Functions inherited from MayaFlux::Nodes::Node | |
| virtual void | reset_processed_state_internal () |
| Resets the processed state of the node directly. | |
| Protected Attributes inherited from MayaFlux::Nodes::GpuSync::GeometryWriterNode | |
| GeometryContext | m_context { 0.0, {}, 0, 0 } |
| std::vector< uint32_t > | m_index_buffer |
| Optional index buffer for indexed drawing (not used by default) | |
| bool | m_needs_layout_update {} |
| Flag indicating if layout needs update. | |
| std::vector< uint8_t > | m_vertex_buffer |
| Vertex data buffer (flat array of bytes) | |
| uint32_t | m_vertex_count {} |
| Number of vertices in buffer. | |
| bool | m_vertex_data_dirty { true } |
| Flag: vertex data or layout changed since last GPU upload. | |
| std::optional< Kakshya::VertexLayout > | m_vertex_layout |
| Cached vertex layout for descriptor binding. | |
| size_t | m_vertex_stride {} |
| Bytes per vertex (stride for vertex buffer binding) | |
| Protected Attributes inherited from MayaFlux::Nodes::Node | |
| 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. | |
| uint32_t | m_frame_rate { 60 } |
| Frame rate for time-based processing, used for normalization. | |
| 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. | |
| double | m_last_output { 0 } |
| The most recent sample value generated by this oscillator. | |
| 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. | |
| uint8_t | m_node_capability { NodeCapability::SCALAR } |
| Bitmask of capabilities declared by this node. | |
| uint32_t | m_sample_rate { 48000 } |
| Sample rate for audio processing, used for normalization. | |
| bool | m_state_saved {} |
| tracks if the node's state has been saved by a snapshot operation | |
| uint32_t | m_timing_rate { m_sample_rate } |
| Current timing rate for the node, used for timing calculations (can be sample rate or frame rate) | |
Detailed Description
MeshWriterNode that extracts a TRIANGLE_LIST isosurface from a Kinesis::SpatialField each frame via marching cubes.
The field is any glm::vec3 -> float callable wrapped in a SpatialField. Kinesis::TendencyFactories and composition operators (combine, chain, select) provide the full vocabulary without any new types.
The grid is re-evaluated and a new mesh extracted only when the node is marked dirty by a setter call. compute_frame() is otherwise a no-op, making the node safe to tick at VISUAL_RATE for static fields.
Usage:
auto node = std::make_shared<SDFNode>(
return glm::length(p) - 1.0F; // unit sphere
}},
glm::vec3(-1.5F), glm::vec3(1.5F),
32, 32, 32);
buf->setup_rendering({ .target_window = window });
auto GeometryBuffer(Args &&... args) -> std::shared_ptr< MayaFlux::Buffers::GeometryBuffer >
Definition Creator.hpp:139
Typed, composable, stateless callable from domain D to range R.
Definition Tendency.hpp:22
Audio-reactive deformation:
auto radius = make_persistent_shared<std::atomic<float>>(1.0F);
return glm::length(p) - radius->load(std::memory_order_relaxed);
}});
// Audio metro writes radius, graphics metro marks node dirty.
Definition at line 46 of file SDFNode.hpp.
The documentation for this class was generated from the following files:
