Loading...
Searching...
No Matches
Public Types |
Public Member Functions |
Private Member Functions |
Private Attributes |
List of all members
MayaFlux::Buffers::VKBuffer Class Reference
Vulkan-backed buffer wrapper used in processing chains. More...
#include <VKBuffer.hpp>
Inheritance diagram for MayaFlux::Buffers::VKBuffer:
Collaboration diagram for MayaFlux::Buffers::VKBuffer:
Public Types | |
| enum class | Usage : uint8_t { STAGING , DEVICE , COMPUTE , VERTEX , INDEX , UNIFORM } |
Public Member Functions | |
| VKBuffer (size_t size_bytes, Usage usage, Kakshya::DataModality modality) | |
| Construct an unregistered VKBuffer. | |
| VKBuffer ()=default | |
| ~VKBuffer () override | |
| Virtual destructor. | |
| void | clear () override |
| Clear buffer contents. | |
| std::vector< Kakshya::DataVariant > | get_data () |
| Read buffer contents as Kakshya DataVariant. | |
| void | set_data (const std::vector< Kakshya::DataVariant > &data) |
| Write data into the buffer. | |
| void | resize (size_t new_size, bool preserve_data=false) |
| Resize buffer and recreate GPU resources if needed. | |
| size_t | get_size () const |
| Get current logical size in bytes. | |
| void | process_default () override |
| Run the buffer's default processor (if set and enabled) | |
| void | set_default_processor (std::shared_ptr< Buffers::BufferProcessor > processor) override |
| Set the buffer's default processor. | |
| std::shared_ptr< Buffers::BufferProcessor > | get_default_processor () const override |
| Get the currently attached default processor. | |
| std::shared_ptr< Buffers::BufferProcessingChain > | get_processing_chain () override |
| Access the buffer's processing chain. | |
| void | set_processing_chain (std::shared_ptr< Buffers::BufferProcessingChain > chain, bool force=false) override |
| Replace the buffer's processing chain. | |
| bool | has_data_for_cycle () const override |
| Checks if the buffer has data for the current processing cycle. | |
| bool | needs_removal () const override |
| Checks if the buffer should be removed from processing chains. | |
| void | mark_for_processing (bool has_data) override |
| Marks the buffer's data availability for the current processing cycle. | |
| void | mark_for_removal () override |
| Marks the buffer for removal from processing chains. | |
| void | enforce_default_processing (bool should_process) override |
| Controls whether the buffer should use default processing. | |
| bool | needs_default_processing () override |
| Checks if the buffer should undergo default processing. | |
| bool | try_acquire_processing () override |
| Try to acquire processing lock for this buffer. | |
| void | release_processing () override |
| Release previously acquired processing lock. | |
| bool | is_processing () const override |
| Query whether the buffer is currently being processed. | |
| vk::Buffer & | get_buffer () |
| Get VkBuffer handle (VK_NULL_HANDLE if not registered) | |
| vk::DeviceSize | get_size_bytes () const |
| vk::Format | get_format () const |
| Convert modality to a recommended VkFormat. | |
| bool | is_initialized () const |
| Check whether Vulkan handles are present (buffer registered) | |
| virtual void | setup_processors (ProcessingToken token) |
| Setup processors with a processing token. | |
| Kakshya::DataModality | get_modality () const |
| Get the buffer's semantic modality. | |
| const std::vector< Kakshya::DataDimension > & | get_dimensions () const |
| Get the inferred data dimensions for the buffer contents. | |
| void | set_modality (Kakshya::DataModality modality) |
| Update the semantic modality and re-infer dimensions. | |
| Usage | get_usage () const |
| Retrieve the declared usage intent. | |
| void | set_buffer (vk::Buffer buffer) |
| Set VkBuffer handle after backend allocation. | |
| void | set_memory (vk::DeviceMemory memory) |
| Set device memory handle after backend allocation. | |
| void | set_mapped_ptr (void *ptr) |
| Set mapped host pointer (for host-visible allocations) | |
| void | set_buffer_resources (const VKBufferResources &resources) |
| Set all buffer resources at once. | |
| const VKBufferResources & | get_buffer_resources () |
| Get all buffer resources at once. | |
| bool | is_host_visible () const |
| Whether this VKBuffer should be host-visible. | |
| vk::BufferUsageFlags | get_usage_flags () const |
| Get appropriate VkBufferUsageFlags for creation based on Usage. | |
| vk::MemoryPropertyFlags | get_memory_properties () const |
| Get appropriate VkMemoryPropertyFlags for allocation based on Usage. | |
| void * | get_mapped_ptr () const |
| Get mapped host pointer (nullptr if not host-visible or unmapped) | |
| void | mark_dirty_range (size_t offset, size_t size) |
| Get device memory handle. | |
| void | mark_invalid_range (size_t offset, size_t size) |
| Mark a range as invalid (needs download) | |
| std::vector< std::pair< size_t, size_t > > | get_and_clear_dirty_ranges () |
| Retrieve and clear all dirty ranges. | |
| std::vector< std::pair< size_t, size_t > > | get_and_clear_invalid_ranges () |
| Retrieve and clear all invalid ranges. | |
| void | set_pipeline_window (RenderPipelineID id, const std::shared_ptr< Core::Window > &window) |
| Associate this buffer with a window for rendering. | |
| std::shared_ptr< Core::Window > | get_pipeline_window (RenderPipelineID id) const |
| Get the window associated with this buffer. | |
| bool | has_render_pipeline () const |
| Check if this buffer has a rendering pipeline configured. | |
| std::unordered_map< RenderPipelineID, std::shared_ptr< Core::Window > > | get_render_pipelines () const |
| Get all render pipelines associated with this buffer. | |
| void | set_pipeline_command (RenderPipelineID pipeline_id, CommandBufferID cmd_id) |
| Store recorded command buffer for a pipeline. | |
| CommandBufferID | get_pipeline_command (RenderPipelineID pipeline_id) const |
| Get recorded command buffer for a pipeline. | |
| void | clear_pipeline_commands () |
| Clear all recorded commands (called after presentation) | |
| void | set_vertex_layout (const Kakshya::VertexLayout &layout) |
| Set vertex layout for this buffer. | |
| std::optional< Kakshya::VertexLayout > | get_vertex_layout () const |
| Get vertex layout if set. | |
| bool | has_vertex_layout () const |
| Check if this buffer has vertex layout configured. | |
| void | clear_vertex_layout () |
| Clear vertex layout. | |
| std::shared_ptr< Buffer > | clone_to (uint8_t dest_desc) override |
| Creates a clone of this buffer for a specific channel or usage enum. | |
| std::shared_ptr< VKBuffer > | clone_to (Usage usage) |
| Create a clone of this buffer with the same data and properties. | |
| void | force_internal_usage (bool internal) override |
| Set whether this buffer is for internal engine usage. | |
| bool | is_internal_only () const override |
| Check whether this buffer is for internal engine usage. | |
| Public Member Functions inherited from MayaFlux::Buffers::Buffer | |
| virtual | ~Buffer ()=default |
| Virtual destructor for proper resource management. | |
Private Member Functions | |
| void | infer_dimensions_from_data (size_t byte_count) |
| Infer Kakshya::DataDimension entries from a given byte count. | |
Private Attributes | |
| VKBufferResources | m_resources |
| size_t | m_size_bytes {} |
| Usage | m_usage {} |
| Kakshya::DataModality | m_modality |
| std::vector< Kakshya::DataDimension > | m_dimensions |
| std::optional< Kakshya::VertexLayout > | m_vertex_layout |
| bool | m_has_data { true } |
| bool | m_needs_removal {} |
| bool | m_process_default { true } |
| bool | m_internal_usage { false } |
| std::atomic< bool > | m_is_processing |
| std::shared_ptr< Buffers::BufferProcessor > | m_default_processor |
| std::shared_ptr< Buffers::BufferProcessingChain > | m_processing_chain |
| ProcessingToken | m_processing_token |
| std::unordered_map< RenderPipelineID, std::shared_ptr< Core::Window > > | m_window_pipelines |
| std::unordered_map< RenderPipelineID, CommandBufferID > | m_pipeline_commands |
| std::vector< std::pair< size_t, size_t > > | m_dirty_ranges |
| std::vector< std::pair< size_t, size_t > > | m_invalid_ranges |
Detailed Description
Vulkan-backed buffer wrapper used in processing chains.
VKBuffer is a lightweight, high-level representation of a GPU buffer used by the MayaFlux processing pipeline. It carries semantic metadata (Kakshya modalities and dimensions), integrates with the Buffer processing chain and BufferManager, and exposes Vulkan handles once the backend registers the buffer. Prior to registration the object contains no GPU resources and can be manipulated cheaply (like AudioBuffer).
Responsibilities:
- Store buffer size, usage intent and semantic modality
- Provide inferred data dimensions for processors and pipeline inspection
- Hold Vulkan handles (VkBuffer, VkDeviceMemory) assigned by graphics backend
- Provide convenience helpers for common Vulkan creation flags and memory props
- Integrate with BufferProcessor / BufferProcessingChain for default processing
Note: Actual allocation, mapping and command-based transfers are performed by the graphics backend / BufferManager. VKBuffer only stores handles and metadata and provides helpers for processors to operate on it.
Definition at line 52 of file VKBuffer.hpp.
The documentation for this class was generated from the following files:
