◆ done()

SeriesSpec MayaFlux::Portal::Forma::Plot::WaveformBuilder::done ( ) const
Definition at line 207 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 thickness = m_thickness;
 
    return fitted(SeriesSpec {
        .fn = [x_mappings, y_mappings, z_mappings, global_palette, thickness](
                  const std::shared_ptr<Kakshya::PlotContainer>& container,
                  std::vector<uint8_t>& out,
                  Element&) mutable {
            if (!container)
                return;
 
            container->process_default();
 
            struct SeriesEntry {
                std::span<const double> data;
                size_t mapping_index;
                size_t index_within_mapping;
            };
 
            std::vector<SeriesEntry> y_entries;
            for (size_t mi = 0; mi < y_mappings.size(); ++mi) {
                auto series = series_for_mapping(*container, y_mappings[mi]);
                for (size_t si = 0; si < series.size(); ++si)
                    y_entries.push_back({ .data = series[si], .mapping_index = mi, .index_within_mapping = si });
            }
            if (y_entries.empty())
                return;
 
            AxisRange x_range = merge_axis(x_mappings);
            AxisRange z_range = z_mappings.empty() ? AxisRange {} : merge_axis(z_mappings);
 
            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());
            }
 
            apply_auto_scale(x_range, all_x.empty() ? std::vector<std::span<const double>> { y_entries[0].data } : all_x);
            apply_auto_scale(z_range, all_z);
 
            out.clear();
 
            for (size_t ei = 0; ei < y_entries.size(); ++ei) {
                const auto& entry = y_entries[ei];
                const auto& ys = entry.data;
                const size_t n = ys.size();
                if (n == 0)
                    continue;
 
                const glm::vec3 color = resolve_color(
                    y_mappings[entry.mapping_index], global_palette, entry.index_within_mapping);
 
                auto y_range = y_mappings[entry.mapping_index].range;
                apply_auto_scale(y_range, { ys });
 
                const bool has_x = ei < all_x.size() && all_x[ei].size() == n;
                const bool has_z = ei < all_z.size() && all_z[ei].size() == n;
 
                const std::vector<float> xs = has_x
                    ? [&] {
                          std::vector<float> v;
                          v.reserve(n);
                          for (double val : all_x[ei])
                              v.push_back(x_range.to_ndc(static_cast<float>(val)));
                          return v;
                      }()
                    : uniform_x(n, x_range);
 
                for (size_t i = 0; i < n; ++i) {
                    write_vertex(out,
                        { xs[i],
                            y_range.to_ndc(static_cast<float>(ys[i])),
                            has_z ? z_range.to_ndc(static_cast<float>(all_z[ei][i])) : 0.F },
                        color,
                        thickness);
                }
 
                if (ei + 1 < y_entries.size()) {
                    const glm::vec3 sep_pos {
                        xs[n - 1],
                        y_range.to_ndc(static_cast<float>(ys[n - 1])),
                        has_z ? z_range.to_ndc(static_cast<float>(all_z[ei][n - 1])) : 0.F,
                    };
                    write_vertex(out, sep_pos, color, 0.F);
                    write_vertex(out, sep_pos, color, 0.F);
                }
            } },
        .topology = Graphics::PrimitiveTopology::LINE_STRIP,
        .capacity_for = [](uint64_t n) { return (n + 2) * 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: