Proxy box bounding a scalar field, drawn by a fragment stage that integrates the field along the view ray. More...

#include <RaymarchBuffer.hpp>

Inheritance diagram for MayaFlux::Buffers::RaymarchBuffer:

Collaboration diagram for MayaFlux::Buffers::RaymarchBuffer:

Public Member Functions
const Kinesis::Lattice3D &	get_lattice () const
	The lattice the box spans.

std::shared_ptr< RaymarchProcessor >	march_processor () const
	The march staging stage, valid after setup_processors.

	RaymarchBuffer (Kinesis::Lattice3D lattice, RaymarchProcessor::FieldSource source, size_t field_bytes)
	Construct proxy geometry over a lattice.

void	setup_processors (ProcessingToken token) override
	Attach MeshProcessor for upload and RaymarchProcessor for staging.

void	setup_rendering (const RenderConfig &config)
	Attach a RenderProcessor drawing the proxy box.

	~RaymarchBuffer () override=default

Public Member Functions inherited from MayaFlux::Buffers::MeshBuffer
std::optional< Kakshya::MeshAccess >	access () const
	Produce a non-owning MeshAccess view over the internal MeshData.

void	bind_diffuse_texture (std::shared_ptr< Core::VKImage > image, std::string_view binding_name="diffuseTex")
	Bind a diffuse texture to the render processor, if present.

void	clear_indices_dirty () noexcept

void	clear_vertices_dirty () noexcept

std::shared_ptr< Core::VKImage >	get_diffuse_texture () const noexcept

uint32_t	get_face_count () const noexcept

uint32_t	get_index_count () const noexcept

std::shared_ptr< MeshProcessor >	get_mesh_processor () const

std::shared_ptr< Nodes::GpuSync::MeshWriterNode >	get_node () const

const std::optional< Kakshya::RegionGroup > &	get_submeshes () const noexcept

uint32_t	get_vertex_count () const noexcept

const Kakshya::VertexLayout &	get_vertex_layout_ref () const noexcept

bool	has_diffuse_texture () const noexcept

bool	indices_dirty () const noexcept

	MeshBuffer (Kakshya::MeshData data)
	Construct from an owning MeshData.

	MeshBuffer (std::shared_ptr< Nodes::GpuSync::MeshWriterNode > node)
	Construct from a MeshWriterNode.

void	set_index_data (std::span< const uint32_t > indices)
	Replace index data entirely and mark indices dirty.

void	set_mesh_data (Kakshya::MeshData data)
	Replace both vertex and index data atomically and mark both dirty.

void	set_vertex_data (std::span< const uint8_t > bytes)
	Replace vertex bytes entirely and mark vertices dirty.

void	setup_rendering (const RenderConfig &config)
	Attach a RenderProcessor targeting the given window.

bool	vertices_dirty () const noexcept

	~MeshBuffer () override=default

Public Member Functions inherited from MayaFlux::Buffers::VKBuffer
void	clear () override
	Clear buffer contents.

void	clear_pipeline_commands ()
	Clear all recorded commands (called after presentation)

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	enforce_default_processing (bool should_process) override
	Controls whether the buffer should use default processing.

void	force_internal_usage (bool internal) override
	Set whether this buffer is for internal engine usage.

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.

vk::Buffer &	get_buffer ()
	Get VkBuffer handle (VK_NULL_HANDLE if not registered)

VKBufferResources &	get_buffer_resources ()
	Get all buffer resources at once (mutable).

const VKBufferResources &	get_buffer_resources () const
	Get all buffer resources at once (read-only)

std::vector< Kakshya::DataVariant >	get_data ()
	Read buffer contents as Kakshya DataVariant.

std::shared_ptr< Buffers::BufferProcessor >	get_default_processor () const override
	Get the currently attached default processor.

uint64_t	get_device_address () const
	Get the Vulkan device address for this buffer (if applicable)

const std::vector< Kakshya::DataDimension > &	get_dimensions () const
	Get the inferred data dimensions for the buffer contents.

EngineContext &	get_engine_context ()

const EngineContext &	get_engine_context () const

vk::Buffer	get_index_buffer () const
	Return the raw index buffer handle.

size_t	get_index_buffer_size () const
	Number of bytes in the index buffer.

void *	get_mapped_ptr () const
	Get mapped host pointer (nullptr if not host-visible or unmapped)

vk::MemoryPropertyFlags	get_memory_properties () const
	Get appropriate VkMemoryPropertyFlags for allocation based on Usage.

Kakshya::DataModality	get_modality () const
	Get the buffer's semantic modality.

CommandBufferID	get_pipeline_command (RenderPipelineID pipeline_id) const
	Get recorded command buffer for a pipeline.

PipelineContext &	get_pipeline_context ()
	Access the pipeline context for custom metadata (non-const)

const PipelineContext &	get_pipeline_context () const
	Access the pipeline context for custom metadata (const)

std::shared_ptr< Core::Window >	get_pipeline_window (RenderPipelineID id) const
	Get the window associated with this buffer.

std::shared_ptr< Buffers::BufferProcessingChain >	get_processing_chain () override
	Access the buffer's processing chain.

RenderConfig	get_render_config () const
	Get the current render configuration.

std::unordered_map< RenderPipelineID, std::shared_ptr< Core::Window > >	get_render_pipelines () const
	Get all render pipelines associated with this buffer.

virtual std::shared_ptr< RenderProcessor >	get_render_processor () const
	Get a RenderProcessor suitable for rendering this buffer.

size_t	get_size () const
	Get current logical size in bytes.

vk::DeviceSize	get_size_bytes () const

Usage	get_usage () const
	Retrieve the declared usage intent.

vk::BufferUsageFlags	get_usage_flags () const
	Get appropriate VkBufferUsageFlags for creation based on Usage.

std::optional< Kakshya::VertexLayout >	get_vertex_layout () const
	Get vertex layout if set.

bool	has_data_for_cycle () const override
	Checks if the buffer has data for the current processing cycle.

bool	has_index_buffer () const
	True when an index buffer has been associated with this buffer.

bool	has_render_pipeline () const
	Check if this buffer has a rendering pipeline configured.

bool	has_vertex_layout () const
	Check if this buffer has vertex layout configured.

bool	is_host_visible () const
	Whether this VKBuffer should be host-visible.

bool	is_initialized () const
	Check whether Vulkan handles are present (buffer registered)

bool	is_internal_only () const override
	Check whether this buffer is for internal engine usage.

bool	is_processing () const override
	Query whether the buffer is currently being processed.

bool	is_render_config_dirty () const
	Check if config has changed since last frame.

void	mark_dirty_range (size_t offset, size_t size)
	Get device memory handle.

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	mark_invalid_range (size_t offset, size_t size)
	Mark a range as invalid (needs download)

virtual void	mark_render_config_dirty (bool is_dirty=true)
	Mark config as changed (processors will detect and react)

bool	needs_default_processing () override
	Checks if the buffer should undergo default processing.

bool	needs_depth_attachment () const
	Check if this buffer requires depth attachment for rendering.

bool	needs_removal () const override
	Checks if the buffer should be removed from processing chains.

void	process_default () override
	Run the buffer's default processor (if set and enabled)

void	release_processing () override
	Release previously acquired processing lock.

void	resize (size_t new_size, bool preserve_data=false)
	Resize buffer and recreate GPU resources if needed.

void	set_buffer (vk::Buffer buffer)
	Set VkBuffer handle after backend allocation.

void	set_buffer_resources (const VKBufferResources &resources)
	Set all buffer resources at once.

void	set_data (const std::vector< Kakshya::DataVariant > &data)
	Write data into the buffer.

void	set_default_processor (const std::shared_ptr< BufferProcessor > &processor) override
	Set the buffer's default processor.

void	set_index_resources (vk::Buffer buf, vk::DeviceMemory mem, size_t size)
	Store raw index buffer handles produced by the geometry upload path.

void	set_mapped_ptr (void *ptr)
	Set mapped host pointer (for host-visible allocations)

void	set_memory (vk::DeviceMemory memory)
	Set device memory handle after backend allocation.

void	set_modality (Kakshya::DataModality modality)
	Update the semantic modality and re-infer dimensions.

void	set_needs_depth_attachment (bool needs)
	Mark this buffer as requiring depth testing when rendered.

void	set_pipeline_command (RenderPipelineID pipeline_id, CommandBufferID cmd_id)
	Store recorded command buffer for a pipeline.

void	set_pipeline_window (RenderPipelineID id, const std::shared_ptr< Core::Window > &window)
	Associate this buffer with a window for rendering.

void	set_processing_chain (const std::shared_ptr< BufferProcessingChain > &chain, bool force=false) override
	Replace the buffer's processing chain.

virtual void	set_render_config (const RenderConfig &config)
	Update the render configuration and mark as dirty.

void	set_render_processor (std::shared_ptr< RenderProcessor > rp)

void	set_vertex_layout (const Kakshya::VertexLayout &layout)
	Set vertex layout for this buffer.

bool	try_acquire_processing () override
	Try to acquire processing lock for this buffer.

	VKBuffer ()=default

	VKBuffer (size_t size_bytes, Usage usage, Kakshya::DataModality modality=Kakshya::DataModality::VERTICES_3D)
	Construct an unregistered VKBuffer.

	~VKBuffer () override
	Virtual destructor.

Public Member Functions inherited from MayaFlux::Buffers::Buffer
virtual	~Buffer ()=default
	Virtual destructor for proper resource management.

Private Attributes
size_t	m_field_bytes

Kinesis::Lattice3D	m_lattice

std::shared_ptr< RaymarchProcessor >	m_march_processor

RaymarchProcessor::FieldSource	m_source

Additional Inherited Members
Public Types inherited from MayaFlux::Buffers::VKBuffer
using	RenderConfig = Portal::Graphics::RenderConfig

using	Usage = Portal::Graphics::BufferUsageHint

Protected Member Functions inherited from MayaFlux::Buffers::VKBuffer
void	apply_render_config (const RenderConfig &config, const ShaderConfig &shader_config)
	Configure the internal m_render_processor from a RenderConfig.

void	apply_render_config (std::shared_ptr< RenderProcessor > &render_processor, const RenderConfig &config, const ShaderConfig &shader_config)
	Configure a RenderProcessor, creating one if null.

void	set_default_render_config (const RenderConfig &config)
	Called by derived classes to set their context-specific defaults.

Protected Attributes inherited from MayaFlux::Buffers::VKBuffer
RenderConfig	m_render_config

bool	m_render_config_dirty {}

std::shared_ptr< RenderProcessor >	m_render_processor

Detailed Description

Proxy box bounding a scalar field, drawn by a fragment stage that integrates the field along the view ray.

A MeshBuffer holding the box Kinesis::generate_box produces over a Lattice3D's bounds. MeshProcessor uploads it and links the index buffer, so the geometry path is the ordinary indexed mesh path with nothing special about it. The image is produced entirely in the fragment stage; the box only rasterises the pixels the march covers.

Owns no field. The field arrives through RaymarchProcessor's source callable, so a VolumeGridBuffer running its own simulation chain is untouched and its field is read where it lies.

Back faces are rasterised rather than front, and the fragment stage clips ray entry against the box, so the volume survives the observer moving inside its bounds.

Definition at line 28 of file RaymarchBuffer.hpp.

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description