◆ done()

SeriesSpec MayaFlux::Portal::Forma::Plot::ScatterBuilder::done ( ) const
Definition at line 287 of file SeriesBuilder.cpp.
{
    auto x_mappings = m_state.x_mappings();
    auto y_mappings = m_state.y_mappings();
    auto z_mappings = m_state.z_mappings();
    const auto global_palette = m_state.palette();
    const float point_size = m_point_size;
 
    return {
        .fn = [x_mappings, y_mappings, z_mappings, global_palette, point_size](
                  const std::shared_ptr<Kakshya::PlotContainer>& container,
                  std::vector<uint8_t>& out,
                  Element&) mutable {
        if (!container)
            return;
 
        container->process_default();
 
        std::vector<std::span<const double>> all_x, all_z;
        for (auto& m : x_mappings) {
            auto s = series_for_mapping(*container, m);
            all_x.insert(all_x.end(), s.begin(), s.end());
        }
        for (auto& m : z_mappings) {
            auto s = series_for_mapping(*container, m);
            all_z.insert(all_z.end(), s.begin(), s.end());
        }
 
        AxisRange x_range = merge_axis(x_mappings);
        AxisRange z_range = z_mappings.empty() ? AxisRange {} : merge_axis(z_mappings);
        apply_auto_scale(x_range, all_x);
        apply_auto_scale(z_range, all_z);
 
        out.clear();
 
        size_t global_idx = 0;
        for (auto& y_mapping : y_mappings) {
            auto y_series = series_for_mapping(*container, y_mapping);
            auto y_range = y_mapping.range;
            apply_auto_scale(y_range, y_series);
 
            for (size_t si = 0; si < y_series.size(); ++si, ++global_idx) {
                const auto& ys = y_series[si];
                const size_t n = ys.size();
                if (n == 0)
                    continue;
 
                const glm::vec3 color = resolve_color(y_mapping, global_palette, si);
                const size_t x_idx = std::min(global_idx, all_x.empty() ? size_t(0) : all_x.size() - 1);
                const bool has_x = !all_x.empty() && all_x[x_idx].size() == n;
                const bool has_z = global_idx < all_z.size() && all_z[global_idx].size() == n;
 
                for (size_t i = 0; i < n; ++i) {
                    const float px = has_x
                        ? x_range.to_ndc(static_cast<float>(all_x[x_idx][i]))
                        : x_range.to_ndc(x_range.min
                              + static_cast<float>(i) / static_cast<float>(std::max<size_t>(n - 1, 1))
                                  * (x_range.max - x_range.min));
 
                    write_vertex(out,
                        { px,
                            y_range.to_ndc(static_cast<float>(ys[i])),
                            has_z ? z_range.to_ndc(static_cast<float>(all_z[global_idx][i])) : 0.F },
                        color,
                        point_size);
                }
            }
        } },
        .topology = Graphics::PrimitiveTopology::POINT_LIST,
        .capacity_for = [](uint64_t n) { return n * k_stride; },
        .background_fn = m_state.has_background()
            ? std::optional<GeometryFn<float>> { background(m_state.background_bounds(), m_state.background_color()) }
            : std::nullopt,
        .plot_bounds = m_state.plot_bounds(),
        .labels = m_state.labels(),
        .tick_labels = m_state.resolved_tick_labels(),
        .legend = m_state.legend_spec(),
    };
}
Here is the call graph for this function: