setup_rendering()

void MayaFlux::Buffers::FormaBuffer::setup_rendering

(

const RenderConfig &

config

)

Attach a RenderProcessor targeting the given window.

Selects default shaders from topology set at construction. Always enables alpha blending, disables depth testing. Caller may override shaders via config fields.

TRIANGLE_LIST/TRIANGLE_STRIP picks its fragment shader from texture state (forma_multi/forma_textured/triangle.frag) regardless of triangulate – PrimitiveMill's triangle pass copies UV unchanged, so texturing stays correct either way; it never falls back to milled_shape.frag, which would blank every textured scene.

POINT_LIST does switch under triangulate, to milled_shape.vert plus milled_shape.frag/_textured/_multi depending on texture state (point.frag's gl_PointCoord is meaningless once forced TRIANGLE_LIST). The multi variant's array index shares the scalar slot PrimitiveMill reads as point size – set_mill_spec(use_vertex_extent = false) decouples them; left default, size and index are the same number.

Definition at line 57 of file FormaBuffer.cpp.

{
    RenderConfig resolved = config;
    resolved.topology = m_topology;
 
    const bool single_tex = !config.default_texture_binding.empty();
    const auto multi_count = static_cast<uint32_t>(config.additional_textures.size());
    const bool multi_tex = multi_count > 0;
 
    switch (resolved.topology) {
    case Portal::Graphics::PrimitiveTopology::POINT_LIST:
        if (resolved.triangulate) {
            if (resolved.vertex_shader.empty())
                resolved.vertex_shader = "milled_shape.vert.spv";
            if (resolved.fragment_shader.empty()) {
                if (multi_tex) {
                    resolved.fragment_shader = "milled_shape_multi.frag.spv";
                } else if (single_tex) {
                    resolved.fragment_shader = "milled_shape_textured.frag.spv";
                } else {
                    resolved.fragment_shader = "milled_shape.frag.spv";
                }
            }
        } else {
            if (resolved.vertex_shader.empty())
                resolved.vertex_shader = "point.vert.spv";
            if (resolved.fragment_shader.empty())
                resolved.fragment_shader = "point.frag.spv";
        }
        break;
 
    case Portal::Graphics::PrimitiveTopology::LINE_LIST:
    case Portal::Graphics::PrimitiveTopology::LINE_STRIP:
        if (resolved.vertex_shader.empty())
            resolved.vertex_shader = "line.vert.spv";
        if (resolved.fragment_shader.empty())
            resolved.fragment_shader = "line.frag.spv";
#ifdef MAYAFLUX_PLATFORM_MACOS
        resolved.triangulate = true;
#endif
 
        if (resolved.triangulate) {
            resolved.geometry_shader.clear();
        } else if (resolved.geometry_shader.empty()) {
            resolved.geometry_shader = "line.geom.spv";
        }
 
        break;
 
    case Portal::Graphics::PrimitiveTopology::TRIANGLE_LIST:
    case Portal::Graphics::PrimitiveTopology::TRIANGLE_STRIP:
        if (resolved.vertex_shader.empty())
            resolved.vertex_shader = multi_tex ? "triangle_multi.vert.spv" : "triangle.vert.spv";
        if (resolved.fragment_shader.empty()) {
            if (multi_tex) {
                resolved.fragment_shader = "forma_multi.frag.spv";
            } else if (single_tex) {
                resolved.fragment_shader = "forma_textured.frag.spv";
            } else {
                resolved.fragment_shader = "triangle.frag.spv";
            }
        }
        break;
 
    default:
        if (resolved.vertex_shader.empty())
            resolved.vertex_shader = "point.vert.spv";
        if (resolved.fragment_shader.empty())
            resolved.fragment_shader = "point.frag.spv";
        break;
    }
 
    ShaderConfig sc { resolved.vertex_shader };
    if (multi_tex) {
        const uint32_t total = single_tex ? 1 + multi_count : multi_count;
        sc.bindings["textures"] = ShaderBinding(
            0, 1, vk::DescriptorType::eCombinedImageSampler, total);
    } else if (single_tex) {
        sc.bindings[config.default_texture_binding] = ShaderBinding(
            0, 1, vk::DescriptorType::eCombinedImageSampler);
    }
 
    apply_render_config(resolved, sc);
    m_render_processor->enable_alpha_blending();
 
    if (multi_tex) {
        uint32_t slot = 1;
        if (single_tex && !config.default_texture_binding.empty()) {
            auto it = std::ranges::find_if(config.additional_textures,
                [&](const auto& p) { return p.first == config.default_texture_binding; });
            if (it != config.additional_textures.end()) {
                m_render_processor->bind_texture(slot, it->second);
                ++slot;
            }
        }
        for (const auto& [name, img] : config.additional_textures) {
            if (single_tex && name == config.default_texture_binding)
                continue;
 
            if (img)
                m_render_processor->bind_texture(slot, img);
 
            ++slot;
        }
    }
 
    get_processing_chain()->add_final_processor(m_render_processor, shared_from_this());
    set_default_render_config(resolved);
}

References MayaFlux::Portal::Graphics::RenderConfig::additional_textures, MayaFlux::Buffers::VKBuffer::apply_render_config(), MayaFlux::Portal::Graphics::RenderConfig::default_texture_binding, MayaFlux::Portal::Graphics::RenderConfig::fragment_shader, MayaFlux::Portal::Graphics::RenderConfig::geometry_shader, MayaFlux::Buffers::VKBuffer::get_processing_chain(), MayaFlux::Portal::Graphics::LINE_LIST, MayaFlux::Portal::Graphics::LINE_STRIP, MayaFlux::Buffers::VKBuffer::m_render_processor, m_topology, name, MayaFlux::Portal::Graphics::POINT_LIST, MayaFlux::Buffers::VKBuffer::set_default_render_config(), MayaFlux::Portal::Graphics::RenderConfig::topology, total, MayaFlux::Portal::Graphics::TRIANGLE_LIST, MayaFlux::Portal::Graphics::TRIANGLE_STRIP, MayaFlux::Portal::Graphics::RenderConfig::triangulate, and MayaFlux::Portal::Graphics::RenderConfig::vertex_shader.

Here is the call graph for this function: