add_render_sink()

MAYAFLUX_API void MayaFlux::Nexus::add_render_sink	(	std::vector< RenderSink > &	sinks,
		Buffers::BufferManager &	mgr,
		const Portal::Graphics::RenderConfig &	config,
		RenderFn	fn = {},
		std::string	fn_name = {},
		const std::optional< glm::vec3 > &	initial_position = {}
	)

Create and register a render sink targeting window.

Allocates a VKBuffer (VERTEX, POINT_LIST), attaches a DataWriteProcessor and a RenderProcessor with point.vert.spv / point.frag.spv defaults, and registers the buffer with mgr.

Parameters

sinks	Sink vector owned by the calling Emitter or Agent.
mgr	BufferManager to register the VKBuffer with.
window	Target window for presentation.
fn	Optional producer called each dispatch with InfluenceContext. Leave empty when geometry is supplied via push_geometry().
fn_name	Optional identifier for state encoding, empty if anonymous.
initial_position	Optional initial position to write if no producer fn is set.

Definition at line 95 of file Sinks.cpp.

{
    constexpr size_t k_initial_bytes = 4096;
 
    auto buf = std::make_shared<Buffers::VKBuffer>(
        k_initial_bytes,
        Buffers::VKBuffer::Usage::VERTEX,
        Kakshya::DataModality::VERTICES_3D);
 
    auto writer = std::make_shared<Buffers::DataWriteProcessor>();
    buf->set_default_processor(writer);
    mgr.add_buffer(buf, Buffers::ProcessingToken::GRAPHICS_BACKEND);
 
    auto rc = config;
 
    if (rc.vertex_shader.empty() || rc.fragment_shader.empty()) {
        switch (rc.topology) {
        case Portal::Graphics::PrimitiveTopology::LINE_LIST:
        case Portal::Graphics::PrimitiveTopology::LINE_STRIP:
            if (rc.vertex_shader.empty())
                rc.vertex_shader = "line.vert.spv";
            if (rc.fragment_shader.empty())
                rc.fragment_shader = "line.frag.spv";
#ifdef MAYAFLUX_PLATFORM_MACOS
            rc.triangulate = true;
#endif
 
            if (rc.triangulate) {
                rc.geometry_shader.clear();
            } else if (rc.geometry_shader.empty()) {
                rc.geometry_shader = "line.geom.spv";
            }
            break;
        case Portal::Graphics::PrimitiveTopology::TRIANGLE_LIST:
        case Portal::Graphics::PrimitiveTopology::TRIANGLE_STRIP:
            if (rc.vertex_shader.empty())
                rc.vertex_shader = "triangle.vert.spv";
            if (rc.fragment_shader.empty())
                rc.fragment_shader = "triangle.frag.spv";
            break;
        default:
            if (rc.triangulate) {
                if (rc.vertex_shader.empty())
                    rc.vertex_shader = "milled_shape.vert.spv";
                if (rc.fragment_shader.empty())
                    rc.fragment_shader = "milled_shape.frag.spv";
            } else {
                if (rc.vertex_shader.empty())
                    rc.vertex_shader = "point.vert.spv";
                if (rc.fragment_shader.empty())
                    rc.fragment_shader = "point.frag.spv";
            }
            break;
        }
    }
 
    auto renderer = std::make_shared<Buffers::RenderProcessor>(Buffers::ShaderConfig { rc.vertex_shader });
    renderer->set_fragment_shader(rc.fragment_shader);
 
    if (!rc.geometry_shader.empty())
        renderer->set_geometry_shader(rc.geometry_shader);
 
    renderer->set_primitive_topology(rc.topology);
    renderer->set_triangulate(rc.triangulate);
    renderer->set_polygon_mode(rc.polygon_mode);
    renderer->set_cull_mode(rc.cull_mode);
 
    renderer->enable_depth_test();
    buf->set_needs_depth_attachment(true);
 
    renderer->set_target_window(rc.target_window, buf);
    buf->set_render_processor(renderer);
    buf->get_processing_chain()->add_final_processor(renderer, buf);
 
    auto& sink = sinks.emplace_back(RenderSink {
        .buf = buf,
        .writer = std::move(writer),
        .renderer = std::move(renderer),
        .fn = std::move(fn),
        .fn_name = std::move(fn_name),
        .window = rc.target_window,
    });
 
    if (!sink.fn && initial_position.has_value()) {
        sink.writer->set_data(std::vector<Kakshya::DataVariant> {
            Kakshya::DataVariant { std::vector<glm::vec3> { *initial_position } },
        });
    }
 
    MF_DEBUG(Journal::Component::Buffers, Journal::Context::Init,
        "Nexus: render sink added");
}

References MayaFlux::Buffers::BufferManager::add_buffer(), MayaFlux::Nexus::RenderSink::buf, MayaFlux::Journal::Buffers, MayaFlux::Buffers::GRAPHICS_BACKEND, MayaFlux::Journal::Init, MayaFlux::Portal::Graphics::LINE_LIST, MayaFlux::Portal::Graphics::LINE_STRIP, MF_DEBUG, MayaFlux::Portal::Graphics::TRIANGLE_LIST, MayaFlux::Portal::Graphics::TRIANGLE_STRIP, MayaFlux::Portal::Graphics::RenderConfig::vertex_shader, and MayaFlux::Kakshya::VERTICES_3D.

Referenced by MayaFlux::Nexus::Agent::render(), MayaFlux::Nexus::Emitter::render(), MayaFlux::Nexus::Agent::render(), and MayaFlux::Nexus::Emitter::render().

Here is the call graph for this function:

Here is the caller graph for this function: