bind_geometry_node()

void MayaFlux::Buffers::GeometryBindingsProcessor::bind_geometry_node	(	const std::string &	name,
		const std::shared_ptr< Nodes::GpuSync::GeometryWriterNode > &	node,
		const std::shared_ptr< VKBuffer > &	vertex_buffer
	)

Bind a geometry node to a GPU vertex buffer.

Parameters

name	Logical name for this binding
node	GeometryWriterNode to read vertices from
vertex_buffer	GPU vertex buffer to upload to

If vertex_buffer is device-local, a staging buffer is automatically created. If vertex_buffer is host-visible, no staging is needed.

Definition at line 20 of file GeometryBindingsProcessor.cpp.

{
    if (!node) {
        error<std::invalid_argument>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "Cannot bind null geometry node '{}'", name);
    }
 
    if (!vertex_buffer) {
        error<std::invalid_argument>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "Cannot bind geometry node '{}' to null vertex buffer", name);
    }
 
    size_t vertex_data_size = node->get_vertex_buffer_size_bytes();
 
    if (vertex_buffer->get_size_bytes() < vertex_data_size) {
        MF_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Vertex buffer for '{}' may be too small: {} bytes required, {} available. "
            "Will upload partial data.",
            name, vertex_data_size, vertex_buffer->get_size_bytes());
    }
 
    std::shared_ptr<VKBuffer> staging = nullptr;
    if (!vertex_buffer->is_host_visible()) {
        size_t staging_size = std::max<size_t>(vertex_buffer->get_size_bytes(), vertex_data_size);
        staging = create_staging_buffer(staging_size);
 
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Created staging buffer for device-local geometry '{}' ({} bytes)",
            name, staging_size);
    } else {
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "No staging needed for host-visible geometry '{}'", name);
    }
 
    std::shared_ptr<VKBuffer> index_buf = nullptr;
    std::shared_ptr<VKBuffer> index_staging_buf = nullptr;
 
    if (node->has_indices()) {
        const size_t index_data_size = node->get_index_count() * sizeof(uint32_t);
        index_buf = std::make_shared<VKBuffer>(
            index_data_size,
            VKBuffer::Usage::INDEX,
            Kakshya::DataModality::UNKNOWN);
 
        ensure_initialized(index_buf);
 
        index_staging_buf = create_staging_buffer(index_data_size);
        MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Created index staging buffer for device-local geometry '{}' ({} bytes)",
            name, index_data_size);
    }
 
    m_bindings[name] = GeometryBinding {
        .node = node,
        .gpu_vertex_buffer = vertex_buffer,
        .staging_buffer = staging,
        .gpu_index_buffer = index_buf,
        .index_staging_buffer = index_staging_buf
    };
 
    MF_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
        "Bound geometry node '{}' ({} vertices, {} bytes, stride: {}, indices: {})",
        name, node->get_vertex_count(), vertex_data_size, node->get_vertex_stride(),
        node->get_index_count());
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Buffers::create_staging_buffer(), MayaFlux::Buffers::VKBufferProcessor::ensure_initialized(), MayaFlux::Buffers::VKBuffer::INDEX, m_bindings, MF_DEBUG, MF_WARN, MayaFlux::Buffers::GeometryBindingsProcessor::GeometryBinding::node, and MayaFlux::Kakshya::UNKNOWN.

Here is the call graph for this function: