MayaFlux::Buffers::ComputeProcessor Class Reference

Specialized ShaderProcessor for Compute Pipelines. More...

#include <ComputeProcessor.hpp>

Inheritance diagram for MayaFlux::Buffers::ComputeProcessor:

Collaboration diagram for MayaFlux::Buffers::ComputeProcessor:

Public Member Functions
	ComputeProcessor (const std::string &shader_path, uint32_t workgroup_x=256)
	Construct processor with shader path.
void	set_workgroup_size (uint32_t x, uint32_t y=1, uint32_t z=1)
	Set workgroup size (should match shader local_size)
void	set_dispatch_mode (ShaderDispatchConfig::DispatchMode mode)
	Set dispatch mode.
void	set_manual_dispatch (uint32_t x, uint32_t y=1, uint32_t z=1)
	Set manual dispatch group counts.
void	set_custom_dispatch (std::function< std::array< uint32_t, 3 >(const std::shared_ptr< VKBuffer > &)> calculator)
	Set custom dispatch calculator.
const ShaderDispatchConfig &	get_dispatch_config () const
	Get current dispatch configuration.
bool	is_pipeline_ready () const
	Check if pipeline is created.
Public Member Functions inherited from MayaFlux::Buffers::ShaderProcessor
	ShaderProcessor (const std::string &shader_path)
	Construct processor with shader path.
	ShaderProcessor (ShaderConfig config)
	Construct processor with full configuration.
	~ShaderProcessor () override
void	processing_function (const std::shared_ptr< Buffer > &buffer) override
	The core processing function that must be implemented by derived classes.
void	on_attach (const std::shared_ptr< Buffer > &buffer) override
	Called when this processor is attached to a buffer.
void	on_detach (const std::shared_ptr< Buffer > &buffer) override
	Called when this processor is detached from a buffer.
bool	is_compatible_with (const std::shared_ptr< Buffer > &buffer) const override
	Checks if this processor can handle the specified buffer type.
void	bind_buffer (const std::string &descriptor_name, const std::shared_ptr< VKBuffer > &buffer)
	Bind a VKBuffer to a named shader descriptor.
void	unbind_buffer (const std::string &descriptor_name)
	Unbind a buffer from a descriptor.
std::shared_ptr< VKBuffer >	get_bound_buffer (const std::string &descriptor_name) const
	Get bound buffer for a descriptor name.
void	auto_bind_buffer (const std::shared_ptr< VKBuffer > &buffer)
	Auto-bind buffer based on attachment order.
bool	hot_reload_shader ()
	Hot-reload shader from ShaderFoundry.
void	set_shader (const std::string &shader_path)
	Update shader path and reload.
const std::string &	get_shader_path () const
	Get current shader path.
void	set_push_constant_size (size_t size)
	Set push constant size.
template<typename T >
void	set_push_constant_size ()
	Set push constant size from type.
template<typename T >
void	set_push_constant_data (const T &data)
	Update push constant data (type-safe)
void	set_push_constant_data_raw (const void *data, size_t size)
	Update push constant data (raw bytes)
const std::vector< uint8_t > &	get_push_constant_data () const
	Get current push constant data.
std::vector< uint8_t > &	get_push_constant_data ()
void	set_specialization_constant (uint32_t constant_id, uint32_t value)
	Set specialization constant.
void	clear_specialization_constants ()
	Clear all specialization constants.
void	set_config (const ShaderConfig &config)
	Update entire configuration.
const ShaderConfig &	get_config () const
	Get current configuration.
void	add_binding (const std::string &descriptor_name, const ShaderBinding &binding)
	Add descriptor binding configuration.
virtual BufferUsageHint	get_buffer_usage_hint (const std::string &descriptor_name) const
	Get buffer usage hint for a descriptor.
virtual bool	is_in_place_operation (const std::string &descriptor_name) const
	Check if shader modifies a specific buffer in-place.
bool	has_binding (const std::string &descriptor_name) const
	Check if a descriptor binding exists.
std::vector< std::string >	get_binding_names () const
	Get all configured descriptor names.
bool	are_bindings_complete () const
	Check if all required bindings are satisfied.
bool	is_shader_loaded () const
	Check if shader is loaded.
bool	are_descriptors_ready () const
	Check if descriptors are initialized.
size_t	get_bound_buffer_count () const
	Get number of bound buffers.
virtual std::shared_ptr< VKBuffer >	get_output_buffer () const
	Get the output buffer after compute dispatch.
virtual bool	has_executed () const
	Check if compute has been executed at least once.
Public Member Functions inherited from MayaFlux::Buffers::BufferProcessor
virtual	~BufferProcessor ()=default
	Virtual destructor for proper cleanup of derived classes.
void	process (const std::shared_ptr< Buffer > &buffer)
	Applies a computational transformation to the data in the provided buffer.
virtual void	set_processing_token (ProcessingToken token)
	Gets the preferred processing backend for this processor.
virtual ProcessingToken	get_processing_token () const
	Gets the current processing token for this buffer.

Protected Member Functions
virtual std::array< uint32_t, 3 >	calculate_dispatch_size (const std::shared_ptr< VKBuffer > &buffer)
	Calculate dispatch size from buffer.
void	initialize_pipeline (const std::shared_ptr< VKBuffer > &buffer) override
void	initialize_descriptors (const std::shared_ptr< VKBuffer > &buffer) override
void	cleanup () override
Protected Member Functions inherited from MayaFlux::Buffers::ShaderProcessor
virtual void	on_before_compile (const std::string &shader_path)
	Called before shader compilation.
virtual void	on_shader_loaded (Portal::Graphics::ShaderID shader_id)
	Called after shader is loaded.
virtual void	on_before_pipeline_create (Portal::Graphics::ComputePipelineID pipeline_id)
	Called before pipeline creation.
virtual void	on_pipeline_created (Portal::Graphics::ComputePipelineID pipeline_id)
	Called after pipeline is created.
virtual void	on_before_descriptors_create ()
	Called before descriptor sets are created.
virtual void	on_descriptors_created ()
	Called after descriptor sets are created.
virtual bool	on_before_execute (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer)
	Called before each process callback.
virtual void	on_after_execute (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer)
	Called after each process callback.
virtual void	update_descriptors (const std::shared_ptr< VKBuffer > &buffer)
Protected Member Functions inherited from MayaFlux::Buffers::VKBufferProcessor
void	initialize_buffer_service ()
void	initialize_compute_service ()

Private Member Functions
void	execute_shader (const std::shared_ptr< VKBuffer > &buffer) override

Private Attributes
ShaderDispatchConfig	m_dispatch_config
Portal::Graphics::ComputePipelineID	m_pipeline_id = Portal::Graphics::INVALID_COMPUTE_PIPELINE

Additional Inherited Members
Public Types inherited from MayaFlux::Buffers::ShaderProcessor
enum class	BufferUsageHint : uint8_t { NONE = 0 , INPUT_READ = 1 << 0 , OUTPUT_WRITE = 1 << 1 , BIDIRECTIONAL = INPUT_READ | OUTPUT_WRITE }
	Get buffer usage characteristics needed for safe data flow. More...
Protected Attributes inherited from MayaFlux::Buffers::ShaderProcessor
ShaderConfig	m_config
Portal::Graphics::ShaderID	m_shader_id = Portal::Graphics::INVALID_SHADER
std::vector< Portal::Graphics::DescriptorSetID >	m_descriptor_set_ids
Portal::Graphics::CommandBufferID	m_last_command_buffer = Portal::Graphics::INVALID_COMMAND_BUFFER
std::unordered_map< std::string, std::shared_ptr< VKBuffer > >	m_bound_buffers
std::shared_ptr< VKBuffer >	m_last_processed_buffer
std::vector< uint8_t >	m_push_constant_data
bool	m_initialized {}
bool	m_needs_pipeline_rebuild = true
bool	m_needs_descriptor_rebuild = true
size_t	m_auto_bind_index {}
Protected Attributes inherited from MayaFlux::Buffers::VKBufferProcessor
Registry::Service::BufferService *	m_buffer_service = nullptr
Registry::Service::ComputeService *	m_compute_service = nullptr
Protected Attributes inherited from MayaFlux::Buffers::BufferProcessor
ProcessingToken	m_processing_token { ProcessingToken::AUDIO_BACKEND }

Detailed Description

Specialized ShaderProcessor for Compute Pipelines.

ComputeProcessor extends ShaderProcessor to handle the specifics of compute shader execution:

• Pipeline Creation: Creates and manages VKComputePipeline.
• Dispatch Logic: Calculates workgroup counts based on buffer size or manual configuration.
• Execution: Records vkCmdDispatch commands.

It inherits all shader resource management (descriptors, push constants, bindings) from ShaderProcessor, adding only what is necessary for compute dispatch.

Dispatch Modes:

• ELEMENT_COUNT: (Default) Calculates groups based on buffer element count / workgroup size.
• BUFFER_SIZE: Calculates groups based on total buffer bytes / workgroup size.
• MANUAL: Uses fixed group counts (x, y, z).
• CUSTOM: Uses a user-provided lambda to calculate dispatch dimensions.

Usage: // Simple usage - single buffer processor auto processor = std::make_shared<ComputeProcessor>("shaders/kernel.comp"); processor->bind_buffer("input_buffer", my_buffer); my_buffer->set_default_processor(processor);

// Advanced - multi-buffer with explicit bindings ComputeProcessorConfig config("shaders/complex.comp"); config.bindings["input"] = ShaderBinding(0, 0); config.bindings["output"] = ShaderBinding(0, 1); config.dispatch.workgroup_x = 512;

auto processor = std::make_shared<ComputeProcessor>(config); processor->bind_buffer("input", input_buffer); processor->bind_buffer("output", output_buffer);

chain->add_processor(processor, input_buffer); chain->add_processor(processor, output_buffer);

// With push constants struct Params { float scale; uint32_t iterations; }; processor->set_push_constant_size<Params>(); processor->set_push_constant_data(Params{2.0f, 100});

Specialized Processors: class FFTProcessor : public ComputeProcessor { FFTProcessor() : ComputeProcessor("shaders/fft.comp") { configure_fft_bindings(); }

void on_attach(std::shared_ptr<Buffer> buffer) override { ComputeProcessor::on_attach(buffer); // FFT-specific setup } };

Definition at line 88 of file ComputeProcessor.hpp.

---

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

• ComputeProcessor.hpp
• ComputeProcessor.cpp