buffer()

InspectResult MayaFlux::Portal::Forma::Inspector::buffer	(	const std::shared_ptr< Buffers::Buffer > &	buf,
		Surface &	surface,
		LayoutCursor &	cursor,
		float	x_min = -0.95F,
		float	x_max = 0.95F,
		float	row_h = 0.05F,
		int	depth = 0
	)

Inspect a single Buffer: default processor and full processing chain.

Header is the buffer's dynamic type name. Body rows expose the default processor type, then preprocessor, each indexed chain processor, postprocessor, and final processor. Absent slots show "-".

Definition at line 20 of file BufferQuery.cpp.

{
    const float ind = x_min + static_cast<float>(depth) * k_inspect_indent;
    const std::string header_label = Reflect::short_dynamic_type_name(*buf);
 
    std::vector<ValueSpec> values {
        ValueSpec {
            .label = "default_proc",
            .reader = [buf] {
                auto p = buf->get_default_processor();
                return p ? std::string(Reflect::short_dynamic_type_name(*p)) : "-";
            },
        },
    };
 
    auto chain = buf->get_processing_chain();
    if (chain) {
        auto pre = chain->get_preprocessor(buf);
        values.push_back(ValueSpec {
            .label = "pre",
            .reader = [pre] {
                return pre ? std::string(Reflect::short_dynamic_type_name(*pre)) : "-";
            },
        });
 
        const auto& processors = chain->get_processors(buf);
        for (size_t i = 0; i < processors.size(); ++i) {
            auto p = processors[i];
            values.push_back(ValueSpec {
                .label = "chain[" + std::to_string(i) + "]",
                .reader = [p] {
                    return p ? std::string(Reflect::short_dynamic_type_name(*p)) : "-";
                },
            });
        }
 
        auto post = chain->get_postprocessor(buf);
        values.push_back(ValueSpec {
            .label = "post",
            .reader = [post] {
                return post ? std::string(Reflect::short_dynamic_type_name(*post)) : "-";
            },
        });
 
        auto final_p = chain->get_final_processor(buf);
        values.push_back(ValueSpec {
            .label = "final",
            .reader = [final_p] {
                return final_p ? std::string(Reflect::short_dynamic_type_name(*final_p)) : "-";
            },
        });
    }
 
    const auto dims = row_pixel_dims(surface.window(), ind, 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, ind, x_max, row_h, false);
 
    InspectResult result;
    result.group = std::move(group);
    return result;
}

References MayaFlux::Portal::Forma::InspectResult::group, MayaFlux::Portal::Forma::k_inspect_indent, MayaFlux::Portal::Forma::ValueSpec::label, make_row_buffer(), MayaFlux::Portal::Forma::make_value_group(), MayaFlux::Portal::Forma::row_pixel_dims(), MayaFlux::Reflect::short_dynamic_type_name(), and MayaFlux::Portal::Forma::Surface::window().

Referenced by buffer_manager(), root_audio_buffer(), and root_graphics_buffer().

Here is the call graph for this function:

Here is the caller graph for this function: