RelaxationGridBuffer() [1/2]

MayaFlux::Buffers::RelaxationGridBuffer::RelaxationGridBuffer	(	uint32_t	width,
		uint32_t	height,
		size_t	cell_stride_bytes,
		ShaderSource	rule_source,
		ShaderSource	emit_source
	)

Construct an unregistered double-buffered grid buffer.

Parameters

width	Grid width in cells.
height	Grid height in cells.
cell_stride_bytes	Size in bytes of one cell's state.
rule_source	Either a path to a hand-written rule shader (for rules needing branchy multi-state logic, e.g. Conway, Wireworld) or a generated ShaderSpec (e.g. RelaxationSpecs::jacobi_diffusion()).
emit_source	Either a path to a hand-written emit shader, or a generated ShaderSpec that meets the packed vertex contract.

rule_source and emit_source are independent: any pairing meeting their respective contracts is supported. Processors are constructed from whichever alternative each holds in setup_processors().

Definition at line 132 of file RelaxationGridBuffer.cpp.

    : VKBuffer(
          static_cast<size_t>(width) * height * sizeof(Kakshya::Vertex),
          Usage::VERTEX,
          Kakshya::DataModality::VERTEX_POSITIONS_3D)
    , m_width(width)
    , m_height(height)
    , m_cell_stride_bytes(cell_stride_bytes)
    , m_rule_source(std::move(rule_source))
    , m_emit_source(std::move(emit_source))
{
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferManagement,
            std::source_location::current(),
            "RelaxationGridBuffer requires a valid BufferService");
    }
 
    const size_t state_bytes = get_state_bytes();
    const auto usage_flags = static_cast<uint32_t>(
        VkBufferUsageFlags(vk::BufferUsageFlagBits::eStorageBuffer));
    const auto memory_flags = static_cast<uint32_t>(
        VkMemoryPropertyFlags(vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent));
 
    auto& resources = get_buffer_resources();
    resources.back_buffers.resize(2);
 
    for (uint32_t i = 0; i < 2; ++i) {
        void* out_buffer = nullptr;
        void* out_memory = nullptr;
        void* out_mapped = nullptr;
 
        buffer_service->allocate_raw_buffer(
            state_bytes, usage_flags, memory_flags, true,
            out_buffer, out_memory, out_mapped);
 
        resources.back_buffers[i].buffer = static_cast<vk::Buffer>(static_cast<VkBuffer>(out_buffer));
        resources.back_buffers[i].memory = static_cast<vk::DeviceMemory>(static_cast<VkDeviceMemory>(out_memory));
        resources.back_buffers[i].mapped_ptr = out_mapped;
    }
 
    MF_INFO(Journal::Component::Buffers, Journal::Context::Init,
        "RelaxationGridBuffer: {}x{} grid, {} bytes/cell, {} bytes/generation",
        m_width, m_height, m_cell_stride_bytes, state_bytes);
}

References MayaFlux::Journal::BufferManagement, MayaFlux::Journal::Buffers, MayaFlux::Buffers::VKBuffer::get_buffer_resources(), MayaFlux::Registry::BackendRegistry::get_service(), get_state_bytes(), MayaFlux::Journal::Init, MayaFlux::Registry::BackendRegistry::instance(), m_cell_stride_bytes, m_height, m_width, and MF_INFO.

Here is the call graph for this function: