◆ buffer_manager()

InspectResult & MayaFlux::Portal::Forma::Inspector::buffer_manager	(	Surface &	surface,
		LayoutCursor &	cursor,
		float	x_min = `-0.95F`,
		float	x_max = `0.95F`,
		float	row_h = `0.05F`
	)

Inspect the full BufferManager state across all active tokens.

Emits one top-level collapsible per active Buffers::ProcessingToken. Audio tokens (AUDIO_BACKEND, AUDIO_PARALLEL) expand per-channel rows showing sample count, child buffer count, and processing chain state. Graphics tokens (GRAPHICS_BACKEND) expand a single root entry showing VKBuffer child count. All children are related via layer.relate() for cascade.

Persistent: the first call builds the result against surface and cursor and stores it statically. Subsequent calls return the same result regardless of the supplied surface and cursor; the original window remains the render target. To display on a different surface, the process must be restarted.

Definition at line 253 of file BufferQuery.cpp.

{
    if (s_buffer_result) {
        return *s_buffer_result;
    }
 
    const auto tokens = m_bm.get_active_tokens();
    const uint32_t in_count = m_bm.get_num_input_channels();
    const std::string header_label = "BufferManager";
    auto& bm = m_bm;
    std::vector<ValueSpec> values {
        ValueSpec {
            .label = "tokens",
            .reader = [&bm] { return std::to_string(bm.get_active_tokens().size()); },
        },
        ValueSpec {
            .label = "inputs",
            .reader = [&bm] { return std::to_string(bm.get_num_input_channels()); },
        },
    };
 
    const auto dims = row_pixel_dims(surface.window(), x_min, x_max, row_h);
    auto hbuf = make_row_buffer(surface.window(), header_label, dims);
    std::vector<RowBuffer> rbufs;
    rbufs.reserve(values.size());
    for (const auto& spec : values)
        rbufs.push_back(make_row_buffer(surface.window(), spec.label, dims));
 
    auto group = make_value_group(values, std::move(hbuf), rbufs,
        surface, cursor, x_min, x_max, row_h, false);
 
    InspectResult& result = s_buffer_result.emplace();
    result.group = std::move(group);
 
    for (const auto tok : tokens) {
        const bool is_audio = tok == Buffers::ProcessingToken::AUDIO_BACKEND
            || tok == Buffers::ProcessingToken::AUDIO_PARALLEL;
        InspectResult tok_result = is_audio
            ? root_audio_buffer(tok, surface, cursor, x_min, x_max, row_h, 1)
            : root_graphics_buffer(tok, surface, cursor, x_min, x_max, row_h, 1);
        surface.layer().relate(result.group.header.header_id, tok_result.group.header.header_id);
        result.children.push_back(std::move(tok_result));
    }
 
    if (in_count > 0) {
        const std::string in_label = "inputs [" + std::to_string(in_count) + "]";
        const auto in_dims = row_pixel_dims(surface.window(), x_min + k_inspect_indent, x_max, row_h);
        auto in_hbuf = make_row_buffer(surface.window(), in_label, in_dims);
        auto in_group = make_value_group({}, std::move(in_hbuf), {},
            surface, cursor, x_min + k_inspect_indent, x_max, row_h, false);
 
        InspectResult in_result;
        in_result.group = std::move(in_group);
        surface.layer().relate(result.group.header.header_id, in_result.group.header.header_id);
 
        for (uint32_t ch = 0; ch < in_count; ++ch) {
            auto buf = m_bm.get_input_buffer(ch);
            auto buf_result = buffer(
                std::dynamic_pointer_cast<Buffers::Buffer>(buf), surface, cursor,
                x_min, x_max, row_h, 2);
            surface.layer().relate(in_result.group.header.header_id, buf_result.group.header.header_id);
            in_result.children.push_back(std::move(buf_result));
        }
 
        result.children.push_back(std::move(in_result));
    }
 
    return result;
}

Here is the call graph for this function: