VolumeFieldProcessor adding a shaped contribution into a field every cycle. More...

#include <InfluxProcessor.hpp>

Inheritance diagram for MayaFlux::Buffers::InfluxProcessor:

Collaboration diagram for MayaFlux::Buffers::InfluxProcessor:

Classes
struct	InfluxParams
	Push constant block the influx shaders receive. More...

Public Member Functions
float	get_elapsed () const
	Seconds since construction or the last restart.

const std::string &	get_field () const
	Name of the field added into.

	InfluxProcessor (std::string field, const Portal::Graphics::ShaderSpec &spec)
	Construct an influx stage from a generated ShaderSpec.

	InfluxProcessor (std::string field, const std::string &shader_path)
	Construct an influx stage.

void	processing_function (const std::shared_ptr< Buffer > &buffer) override
	The core processing function that must be implemented by derived classes.

void	restart ()
	Reset elapsed time to zero.

void	set_center (const glm::vec3 &center)
	Set the shape's world-space centre.

void	set_falloff (float falloff)
	Set the shape's edge softness.

void	set_radius (float radius)
	Set the shape's characteristic size.

void	set_rate (float rate)
	Set the amount added per unit time at shape value one.

void	set_time_step (float dt)
	Set the integration step.

Public Member Functions inherited from MayaFlux::Buffers::VolumeFieldProcessor
const std::shared_ptr< VolumeGridBuffer > &	get_volume () const
	The attached volume, or null if attachment failed validation.

Public Member Functions inherited from MayaFlux::Buffers::ComputeProcessor
	ComputeProcessor (const Portal::Graphics::ShaderSpec &spec)
	Construct processor from a generated ShaderSpec.

	ComputeProcessor (const std::string &shader_path, uint32_t workgroup_x=256)
	Construct processor with shader path.

const ShaderDispatchConfig &	get_dispatch_config () const
	Get current dispatch configuration.

uint32_t	get_iteration_count () const
	Dispatches recorded per execute cycle.

bool	is_pipeline_ready () const
	Check if pipeline is created.

void	set_custom_dispatch (std::function< std::array< uint32_t, 3 >(const std::shared_ptr< VKBuffer > &)> calculator)
	Set custom dispatch calculator.

void	set_dispatch_mode (ShaderDispatchConfig::DispatchMode mode)
	Set dispatch mode.

void	set_iteration_count (uint32_t count)
	Set how many dispatches are recorded per execute cycle.

void	set_manual_dispatch (uint32_t x, uint32_t y=1, uint32_t z=1)
	Set manual dispatch group counts.

void	set_workgroup_size (uint32_t x, uint32_t y=1, uint32_t z=1)
	Set workgroup size (should match shader local_size)

Public Member Functions inherited from MayaFlux::Buffers::ShaderProcessor
void	add_binding (const std::string &descriptor_name, const ShaderBinding &binding)
	Add descriptor binding configuration.

bool	are_bindings_complete () const
	Check if all required bindings are satisfied.

bool	are_descriptors_ready () const
	Check if descriptors are initialized.

void	auto_bind_buffer (const std::shared_ptr< VKBuffer > &buffer)
	Auto-bind buffer based on attachment order.

void	bind_buffer (const std::string &descriptor_name, const std::shared_ptr< VKBuffer > &buffer)
	Bind a VKBuffer to a named shader descriptor.

void	clear_specialization_constants ()
	Clear all specialization constants.

template<typename T >
bool	download_bound (const std::string &descriptor_name, std::vector< T > &data) const

bool	download_bound (const std::string &descriptor_name, void *data, size_t size, const std::shared_ptr< VKBuffer > &staging=nullptr) const
	Download the buffer currently bound to a named descriptor.

void	feed (const std::string &name, FeedSource source)
	Supply a shader input from a callable, resolved by name.

void	feed (const std::string &name, FeedSource source, uint32_t offset, size_t size=sizeof(float))
	Supply a push constant from a callable at an explicit offset.

std::vector< std::string >	get_binding_names () const
	Get all configured descriptor names.

std::shared_ptr< VKBuffer >	get_bound_buffer (const std::string &descriptor_name) const
	Get bound buffer for a descriptor name.

size_t	get_bound_buffer_count () const
	Get number of bound buffers.

virtual BufferUsageHint	get_buffer_usage_hint (const std::string &descriptor_name) const
	Get buffer usage hint for a descriptor.

const ShaderConfig &	get_config () const
	Get current configuration.

std::vector< std::string >	get_feed_names () const
	Names of every registered feed.

virtual std::shared_ptr< VKBuffer >	get_output_buffer () const
	Get the output buffer after compute dispatch.

std::vector< uint8_t > &	get_push_constant_data ()

const std::vector< uint8_t > &	get_push_constant_data () const
	Get current push constant data.

const std::string &	get_shader_path () const
	Get current shader path.

bool	has_binding (const std::string &descriptor_name) const
	Check if a descriptor binding exists.

virtual bool	has_executed () const
	Check if compute has been executed at least once.

bool	has_feed (const std::string &name) const
	Whether a feed of this name is registered.

bool	hot_reload_shader ()
	Hot-reload shader from ShaderFoundry.

bool	is_compatible_with (const std::shared_ptr< Buffer > &buffer) const override
	Checks if this processor can handle the specified buffer type.

bool	is_deferred_submission () const
	Whether this processor submits asynchronously.

bool	is_dispatch_pending () const
	True while an asynchronous submission is outstanding.

virtual bool	is_in_place_operation (const std::string &descriptor_name) const
	Check if shader modifies a specific buffer in-place.

bool	is_shader_loaded () const
	Check if shader is loaded.

void	on_detach (const std::shared_ptr< Buffer > &buffer) override
	Called when this processor is detached from a buffer.

void	remove_feed (const std::string &name)
	Remove a feed.

bool	resolve_pending_dispatch (bool block)
	Resolve an outstanding asynchronous submission.

void	set_config (const ShaderConfig &config)
	Update entire configuration.

void	set_deferred_submission (bool deferred)
	Submit asynchronously and resolve at the top of a later cycle.

template<typename T >
void	set_push_constant_data (const T &data)
	Update push constant data (type-safe)

virtual void	set_push_constant_data_raw (const void *data, size_t size)
	Update push constant data (raw bytes)

template<typename T >
void	set_push_constant_size ()
	Set push constant size from type.

void	set_push_constant_size (size_t size)
	Set push constant size.

void	set_shader (const std::string &shader_path)
	Update shader path and reload.

void	set_specialization_constant (uint32_t constant_id, uint32_t value)
	Set specialization constant.

	ShaderProcessor (const std::string &shader_path)
	Construct processor with shader path.

	ShaderProcessor (ShaderConfig config)
	Construct processor with full configuration.

void	unbind_buffer (const std::string &descriptor_name)
	Unbind a buffer from a descriptor.

	~ShaderProcessor () override

Public Member Functions inherited from MayaFlux::Buffers::BufferProcessor
virtual ProcessingToken	get_processing_token () const
	Gets the current processing token for this buffer.

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	~BufferProcessor ()=default
	Virtual destructor for proper cleanup of derived classes.

Protected Member Functions
void	on_volume_ready () override
	Raise the parameter block and write everything past the prefix.

Protected Member Functions inherited from MayaFlux::Buffers::VolumeFieldProcessor
void	add_swap_field (std::string field)
	Register a field to swap after each dispatch.

void	on_attach (const std::shared_ptr< Buffer > &buffer) override
	Cache and validate the volume, size the dispatch, write the shared parameter prefix, then call on_volume_ready.

bool	on_before_execute (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer) override
	Reject buffers that are not the validated volume.

void	on_descriptors_created () override
	Write every binding in the table for the current slot assignment.

void	processing_function (const std::shared_ptr< Buffer > &buffer) override
	Rewrite field descriptors, run the shader, then swap.

void	reserve_param_size (size_t size)
	Raise the push constant block to at least this size.

	VolumeFieldProcessor (std::vector< FieldBinding > bindings, const Portal::Graphics::ShaderSpec &spec)
	Construct from a generated ShaderSpec.

	VolumeFieldProcessor (std::vector< FieldBinding > bindings, const std::string &shader_path)
	Construct from a shader path.

virtual bool	wants_swap () const
	Whether this cycle's dispatch should be followed by a swap.

void	write_lattice_params ()
	Write the lattice dimensions and cell size into the staged push constant block, preserving word three.

void	write_lattice_word3 (uint32_t value)
	Write word three of the shared prefix.

void	write_lattice_word7 (float value)
	Write word seven of the parameter prefix, at byte offset 28.

void	write_param_tail (size_t offset, const void *data, size_t size)
	Write subclass parameters past the shared prefix.

Protected Member Functions inherited from MayaFlux::Buffers::ComputeProcessor
virtual std::array< uint32_t, 3 >	calculate_dispatch_size (const std::shared_ptr< VKBuffer > &buffer)
	Calculate dispatch size from buffer.

void	cleanup () override

void	initialize_descriptors (const std::shared_ptr< VKBuffer > &buffer) override

void	initialize_pipeline (const std::shared_ptr< VKBuffer > &buffer) override

virtual bool	on_iteration (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer, uint32_t index)
	Called before each iteration's push constants and dispatch.

virtual void	on_iteration_barrier (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer, uint32_t index)
	Called after each iteration except the last.

Protected Member Functions inherited from MayaFlux::Buffers::ShaderProcessor
virtual void	on_after_execute (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer)
	Called after each process callback.

virtual void	on_before_compile (const std::string &shader_path)
	Called before shader compilation.

virtual void	on_before_descriptors_create ()
	Called before descriptor sets are created.

virtual void	on_before_pipeline_create (Portal::Graphics::ComputePipelineID pipeline_id)
	Called before pipeline creation.

virtual void	on_dispatch_complete (const std::shared_ptr< VKBuffer > &buffer)
	Called once when an asynchronous submission is observed complete.

virtual void	on_pipeline_created (Portal::Graphics::ComputePipelineID pipeline_id)
	Called after pipeline is created.

virtual void	on_shader_loaded (Portal::Graphics::ShaderID shader_id)
	Called after shader is loaded.

void	pump_feeds ()
	Pull every feed and write its result.

std::optional< uint32_t >	resolve_ds_index (uint32_t set) const
	Resolve logical descriptor set index to actual index.

size_t	resolve_push_constant_size (const std::shared_ptr< VKBuffer > &buffer) const
	Byte width of this processor's push constant block, extended to cover any fragment staged on the buffer.

std::vector< uint8_t >	resolve_push_constants (const std::shared_ptr< VKBuffer > &buffer) const
	This processor's push constant data with buffer-staged fragments overlaid at their declared offsets.

void	submit_recorded (Portal::Graphics::CommandBufferID cmd_id, const std::shared_ptr< VKBuffer > &buffer)
	Submit a recorded command buffer honoring the submission mode.

virtual void	update_descriptors (const std::shared_ptr< VKBuffer > &buffer)

Protected Member Functions inherited from MayaFlux::Buffers::VKBufferProcessor
void	ensure_initialized (const std::shared_ptr< VKBuffer > &buffer)

void	initialize_buffer_service ()

void	initialize_compute_service ()

Private Member Functions
void	write_tail ()
	Write every parameter past the shared prefix.

Static Private Member Functions
static std::vector< FieldBinding >	make_bindings (const std::string &field)
	Build the binding table for the field name.

Private Attributes
glm::vec3	m_center { 0.0F }

float	m_elapsed { 0.0F }

float	m_falloff { 1.0F }

std::string	m_field

float	m_radius { 0.15F }

float	m_rate { 1.0F }

float	m_time_step { 1.0F / 60.0F }

Additional Inherited Members
Public Types inherited from MayaFlux::Buffers::VolumeFieldProcessor
enum class	FieldAccess { READ , WRITE }
	Which slot of a field a binding resolves to. More...

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...

using	FeedSource = std::function< FeedValue()>
	A callable pulled once per processing cycle.

using	FeedValue = std::variant< double, Kakshya::DataVariant >
	What a feed callable returns.

Protected Attributes inherited from MayaFlux::Buffers::ShaderProcessor
size_t	m_auto_bind_index {}

std::unordered_map< std::string, std::shared_ptr< VKBuffer > >	m_bound_buffers

ShaderConfig	m_config

bool	m_deferred_submission {}
	False submits synchronously, preserving pre-existing behaviour.

std::vector< Portal::Graphics::DescriptorSetID >	m_descriptor_set_ids

bool	m_engine_owns_set_zero {}
	Whether the engine reserves set=0 for global resources.

bool	m_initialized {}

Portal::Graphics::CommandBufferID	m_last_command_buffer = Portal::Graphics::INVALID_COMMAND_BUFFER

std::shared_ptr< VKBuffer >	m_last_processed_buffer

bool	m_needs_descriptor_rebuild = true

bool	m_needs_pipeline_rebuild = true

std::shared_ptr< VKBuffer >	m_pending_buffer
	Buffer retained for the outstanding submission.

Portal::Graphics::FenceID	m_pending_fence { Portal::Graphics::INVALID_FENCE }
	Outstanding async submission, if any.

std::vector< uint8_t >	m_push_constant_data

Portal::Graphics::ShaderID	m_shader_id = Portal::Graphics::INVALID_SHADER

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

VolumeFieldProcessor adding a shaped contribution into a field every cycle.

The shape lives in the shader. Each concrete shader defines float shape(vec3 p, float t) over world position and elapsed time, includes volume_influx.glsl for the parameter block and the dispatch, and is selected by constructor argument. There is no mode word.

Every cell adds shape * rate * time_step into the field. Nothing here removes anything: a chain with an influx stage and dissipation of exactly one grows without bound. Rate and the carrier's dissipation are a pair and want setting together.

Elapsed time advances by time_step each cycle and is passed to the shape function, so a shader can vary its own geometry over time without the caller driving it. Time is the shared prefix's trailing word.

Parameter offsets past the prefix, for feed(): 32 center x, 36 center y, 40 center z, 44 radius, 48 rate, 52 time step, 56 falloff. The three bounds words at 64 are lattice-derived and not feedable.

Definition at line 31 of file InfluxProcessor.hpp.

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

Classes

Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description