setup_rendering()

void MayaFlux::Buffers::MeshNetworkBuffer::setup_rendering

(

const RenderConfig &

config

)

Attach a RenderProcessor with optional texture support.

Mirrors MeshBuffer::setup_rendering:

• Topology is always TRIANGLE_LIST.
• Defaults to triangle.vert.spv / triangle.frag.spv (untextured) or mesh_textured.frag.spv when a diffuse texture is bound.
• RenderConfig::additional_textures registers extra texture slots.

Definition at line 71 of file MeshNetworkBuffer.cpp.

{
    if (!config.vertex_shader.empty())
        m_render_config.vertex_shader = config.vertex_shader;
    if (!config.fragment_shader.empty())
        m_render_config.fragment_shader = config.fragment_shader;
    if (!config.default_texture_binding.empty()) {
        m_render_config.default_texture_binding = config.default_texture_binding;
        m_diffuse_binding = config.default_texture_binding;
    }
 
    m_render_config.target_window = config.target_window;
    m_render_config.topology = Portal::Graphics::PrimitiveTopology::TRIANGLE_LIST;
    m_render_config.polygon_mode = config.polygon_mode;
    m_render_config.cull_mode = config.cull_mode;
 
    for (const auto& [name, tex] : config.additional_textures)
        m_render_config.additional_textures.emplace_back(name, tex);
 
    const auto slot_count = static_cast<uint32_t>(m_network->slot_count());
 
    const bool has_slot_textures = std::ranges::any_of(
        m_network->slots(),
        [](const auto& slot) { return slot.diffuse_texture != nullptr; });
 
    const bool textured = m_diffuse_texture != nullptr
        || !m_render_config.default_texture_binding.empty()
        || has_slot_textures;
 
    if (textured && m_render_config.default_texture_binding.empty())
        m_render_config.default_texture_binding = m_diffuse_binding;
 
    if (m_render_config.vertex_shader.empty())
        m_render_config.vertex_shader = "mesh_network.vert.spv";
 
    if (m_render_config.fragment_shader.empty()) {
        m_render_config.fragment_shader = textured
            ? "mesh_network_textured.frag.spv"
            : "mesh_network.frag.spv";
    }
 
    ShaderConfig sc { m_render_config.vertex_shader };
 
    sc.bindings["modelMatrices"] = ShaderBinding(0, 1, vk::DescriptorType::eStorageBuffer);
    sc.bindings["slotIndices"] = ShaderBinding(0, 2, vk::DescriptorType::eStorageBuffer);
 
    if (has_slot_textures) {
        sc.bindings["diffuseTex"] = ShaderBinding(
            0, 3, vk::DescriptorType::eCombinedImageSampler, slot_count);
    } else if (textured && !m_render_config.default_texture_binding.empty()) {
        sc.bindings[m_render_config.default_texture_binding] = ShaderBinding(
            0, 3, vk::DescriptorType::eCombinedImageSampler);
    }
 
    uint32_t binding_idx = 0;
    for (const auto& [name, _] : m_render_config.additional_textures)
        sc.bindings[name] = ShaderBinding(1, binding_idx++, vk::DescriptorType::eCombinedImageSampler);
 
    m_render_processor = std::make_shared<RenderProcessor>(sc);
    m_render_processor->set_fragment_shader(m_render_config.fragment_shader);
    m_render_processor->set_target_window(
        m_render_config.target_window,
        std::dynamic_pointer_cast<VKBuffer>(shared_from_this()));
    m_render_processor->set_primitive_topology(m_render_config.topology);
    m_render_processor->set_polygon_mode(m_render_config.polygon_mode);
    m_render_processor->set_cull_mode(m_render_config.cull_mode);
 
    if (has_slot_textures) {
        const auto& slots = m_network->slots();
        const auto& order = m_network->sorted_indices();
        for (uint32_t i = 0; i < static_cast<uint32_t>(order.size()); ++i) {
            const auto& slot = slots[order[i]];
            if (slot.diffuse_texture)
                m_render_processor->bind_texture(3 + i, slot.diffuse_texture);
        }
    } else if (m_diffuse_texture && !m_render_config.default_texture_binding.empty()) {
        m_render_processor->bind_texture(m_render_config.default_texture_binding, m_diffuse_texture);
    }
 
    for (const auto& [name, tex] : m_render_config.additional_textures)
        m_render_processor->bind_texture(name, tex);
 
    get_processing_chain()->add_final_processor(
        m_render_processor,
        shared_from_this());
 
    MF_INFO(Journal::Component::Buffers, Journal::Context::Init,
        "MeshNetworkBuffer::setup_rendering: vert={} frag={} textured={}",
        m_render_config.vertex_shader,
        m_render_config.fragment_shader,
        textured);
}

References MayaFlux::Portal::Graphics::RenderConfig::additional_textures, MayaFlux::Journal::Buffers, MayaFlux::Portal::Graphics::RenderConfig::cull_mode, MayaFlux::Portal::Graphics::RenderConfig::default_texture_binding, MayaFlux::Portal::Graphics::RenderConfig::fragment_shader, MayaFlux::Buffers::VKBuffer::get_processing_chain(), MayaFlux::Journal::Init, m_diffuse_binding, m_diffuse_texture, m_network, m_render_config, m_render_processor, MF_INFO, MayaFlux::Portal::Graphics::RenderConfig::polygon_mode, MayaFlux::Portal::Graphics::RenderConfig::target_window, MayaFlux::Portal::Graphics::RenderConfig::topology, MayaFlux::Portal::Graphics::TRIANGLE_LIST, and MayaFlux::Portal::Graphics::RenderConfig::vertex_shader.

Here is the call graph for this function: