PathGeneratorNode.cpp

Go to the documentation of this file.

#include "PathGeneratorNode.hpp"
 
#include "MayaFlux/Journal/Archivist.hpp"
 
namespace MayaFlux::Nodes::GpuSync {
 
PathGeneratorNode::PathGeneratorNode(
    Kinesis::InterpolationMode mode,
    Eigen::Index samples_per_segment,
    size_t max_control_points,
    double tension)
    : GeometryWriterNode(static_cast<uint32_t>(samples_per_segment * 10))
    , m_mode(mode)
    , m_max_control_points(max_control_points)
    , m_samples_per_segment(samples_per_segment)
    , m_tension(tension)
{
    m_primitive_topology = Portal::Graphics::PrimitiveTopology::LINE_STRIP;
 
    const auto& stride = sizeof(LineVertex);
    set_vertex_stride(stride);
 
    auto layout = Kakshya::VertexLayout::for_lines(stride);
    layout.vertex_count = 0;
    set_vertex_layout(layout);
 
    m_control_points.reserve(max_control_points);
    m_vertices.reserve(samples_per_segment * max_control_points);
 
    MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
        "Created PathGeneratorNode with mode {}, {} samples per segment, capacity {}",
        static_cast<int>(mode), samples_per_segment, max_control_points);
}
 
PathGeneratorNode::PathGeneratorNode(
    CustomPathFunction custom_func,
    Eigen::Index samples_per_segment,
    size_t max_control_points)
    : GeometryWriterNode(static_cast<uint32_t>(samples_per_segment * 10))
    , m_mode(Kinesis::InterpolationMode::CUSTOM)
    , m_custom_func(std::move(custom_func))
    , m_max_control_points(max_control_points)
    , m_samples_per_segment(samples_per_segment)
    , m_tension(0.5)
{
    m_primitive_topology = Portal::Graphics::PrimitiveTopology::LINE_STRIP;
 
    const auto& stride = sizeof(LineVertex);
    set_vertex_stride(stride);
 
    auto layout = Kakshya::VertexLayout::for_lines(stride);
    layout.vertex_count = 0;
    set_vertex_layout(layout);
 
    m_control_points.reserve(max_control_points);
    m_vertices.reserve(samples_per_segment * max_control_points);
 
    MF_DEBUG(Journal::Component::Nodes, Journal::Context::NodeProcessing,
        "Created PathGeneratorNode with custom function");
}
 
void PathGeneratorNode::add_control_point(const LineVertex& vertex)
{
    m_control_points.insert(m_control_points.begin(), vertex);
    if (m_control_points.size() > m_max_control_points) {
        m_control_points.pop_back();
    }
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_geometry_dirty = true;
    m_path_dirty = true;
}
 
size_t PathGeneratorNode::vertices_per_window() const
{
    return static_cast<size_t>(std::max<Eigen::Index>(m_samples_per_segment - 1, 0)) * 2;
}
 
void PathGeneratorNode::write_segment_attributes(
    const std::vector<LineVertex>& curve_verts,
    size_t start_idx,
    LineVertex* dst) const
{
    if (m_samples_per_segment < 2) {
        return;
    }
 
    const auto span = static_cast<size_t>(m_samples_per_segment - 1);
 
    for (size_t i = 0; i < span; ++i) {
        const size_t c0 = start_idx + std::min((i * 3) / span, size_t(3));
        const size_t c1 = start_idx + std::min(((i + 1) * 3) / span, size_t(3));
 
        LineVertex& v0 = dst[i * 2];
        LineVertex& v1 = dst[i * 2 + 1];
 
        v0.color = m_force_uniform_color ? m_current_color : curve_verts[c0].color;
        v1.color = m_force_uniform_color ? m_current_color : curve_verts[c1].color;
 
        v0.thickness = m_force_uniform_thickness ? m_current_thickness : curve_verts[c0].thickness;
        v1.thickness = m_force_uniform_thickness ? m_current_thickness : curve_verts[c1].thickness;
    }
}
 
void PathGeneratorNode::write_curve_segment(
    const std::vector<LineVertex>& curve_verts,
    size_t start_idx,
    LineVertex* dst)
{
    if (start_idx + 3 >= curve_verts.size()) {
        return;
    }
 
    m_evaluator.configure(m_mode, m_tension);
 
    for (size_t i = 0; i < 4; ++i) {
        const auto& pt = curve_verts[start_idx + i].position;
        m_segment_controls[i * 3 + 0] = pt.x;
        m_segment_controls[i * 3 + 1] = pt.y;
        m_segment_controls[i * 3 + 2] = pt.z;
    }
 
    m_evaluator.evaluate_planar(
        m_segment_controls, 3, m_samples_per_segment, m_curve_primary, m_curve_tangents);
 
    const std::vector<double>* curve = &m_curve_primary;
 
    if (m_arc_length_parameterization) {
        m_evaluator.reparameterize_planar(m_curve_primary, 3,
            m_samples_per_segment, m_samples_per_segment, m_curve_secondary);
        curve = &m_curve_secondary;
    }
 
    const auto count = static_cast<size_t>(m_samples_per_segment);
    if (count < 2) {
        return;
    }
 
    const double* x = curve->data();
    const double* y = x + count;
    const double* z = y + count;
 
    if (m_arc_length_parameterization) {
        Kinesis::central_difference_tangents(*curve, 3, count, m_curve_tangents);
    }
 
    const double* tx = m_curve_tangents.data();
    const double* ty = tx + count;
    const double* tz = ty + count;
 
    const auto sample = [&](size_t s) {
        return glm::vec3 {
            static_cast<float>(x[s]), static_cast<float>(y[s]), static_cast<float>(z[s])
        };
    };
 
    const auto tangent = [&](size_t s) {
        return glm::vec3 {
            static_cast<float>(tx[s]), static_cast<float>(ty[s]), static_cast<float>(tz[s])
        };
    };
 
    for (size_t i = 0; i < count - 1; ++i) {
        dst[i * 2].position = sample(i);
        dst[i * 2].tangent = tangent(i);
        dst[i * 2 + 1].position = sample(i + 1);
        dst[i * 2 + 1].tangent = tangent(i + 1);
    }
 
    write_segment_attributes(curve_verts, start_idx, dst);
}
 
void PathGeneratorNode::refresh_attributes()
{
    if (m_mode == Kinesis::InterpolationMode::LINEAR) {
        const size_t n = std::min(m_vertices.size(), m_control_points.size());
        for (size_t i = 0; i < n; ++i) {
            m_vertices[i].color = m_force_uniform_color ? m_current_color : m_control_points[i].color;
            m_vertices[i].thickness = m_force_uniform_thickness ? m_current_thickness : m_control_points[i].thickness;
        }
        return;
    }
 
    if (m_mode == Kinesis::InterpolationMode::CUSTOM) {
        const size_t num_points = m_control_points.size();
        const size_t total = m_vertices.size();
        if (num_points == 0 || total < 2) {
            return;
        }
        for (size_t i = 0; i < total; ++i) {
            const size_t ctrl_idx = std::min((i * (num_points - 1)) / (total - 1), num_points - 1);
            m_vertices[i].color = m_force_uniform_color ? m_current_color : m_control_points[ctrl_idx].color;
            m_vertices[i].thickness = m_force_uniform_thickness ? m_current_thickness : m_control_points[ctrl_idx].thickness;
        }
        return;
    }
 
    if (m_control_points.size() < 4) {
        return;
    }
 
    const size_t per_window = vertices_per_window();
    const size_t windows = m_control_points.size() - 3;
 
    if (m_vertices.size() < windows * per_window) {
        return;
    }
 
    for (size_t w = 0; w < windows; ++w) {
        write_segment_attributes(m_control_points, w, m_vertices.data() + w * per_window);
    }
}
 
void PathGeneratorNode::append_line_segment(
    const LineVertex& v0,
    const LineVertex& v1,
    std::vector<LineVertex>& output)
{
    glm::vec3 color0 = m_force_uniform_color ? m_current_color : v0.color;
    glm::vec3 color1 = m_force_uniform_color ? m_current_color : v1.color;
 
    float thick0 = m_force_uniform_thickness ? m_current_thickness : v0.thickness;
    float thick1 = m_force_uniform_thickness ? m_current_thickness : v1.thickness;
 
    output.push_back({ .position = v0.position, .color = color0, .thickness = thick0 });
    output.push_back({ .position = v1.position, .color = color1, .thickness = thick1 });
}
 
void PathGeneratorNode::draw_to(const LineVertex& vertex)
{
    m_draw_window.push_back(vertex);
 
    if (m_draw_window.size() == 1) {
        LineVertex first = vertex;
        if (m_force_uniform_color) {
            first.color = m_current_color;
        }
        if (m_force_uniform_thickness) {
            first.thickness = m_current_thickness;
        }
        m_draw_vertices.push_back(first);
    } else {
        append_line_segment(
            m_draw_window[m_draw_window.size() - 2],
            vertex,
            m_draw_vertices);
    }
 
    m_path_dirty = true;
}
 
void PathGeneratorNode::set_control_points(const std::vector<LineVertex>& vertices)
{
    m_control_points.assign(vertices.rbegin(), vertices.rend());
    if (m_control_points.size() > m_max_control_points) {
        MF_WARN(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "PathGeneratorNode: {} control points exceed the capacity of {}, keeping the newest {}",
            m_control_points.size(), m_max_control_points, m_max_control_points);
        m_control_points.erase(
            m_control_points.begin() + static_cast<std::ptrdiff_t>(m_max_control_points),
            m_control_points.end());
    }
 
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_path_dirty = true;
    m_geometry_dirty = true;
}
 
void PathGeneratorNode::update_control_point(size_t index, const LineVertex& vertex)
{
    if (index >= m_control_points.size()) {
        MF_ERROR(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Control point index {} out of range (count: {})",
            index, m_control_points.size());
        return;
    }
 
    m_control_points[index] = vertex;
 
    const bool windowed = m_mode != Kinesis::InterpolationMode::LINEAR
        && m_mode != Kinesis::InterpolationMode::CUSTOM
        && m_control_points.size() >= 4;
 
    if (windowed) {
        const size_t windows = m_control_points.size() - 3;
        const size_t first = index >= 3 ? index - 3 : 0;
        const size_t last = std::min(index, windows - 1);
 
        if (m_dirty_segment_start == INVALID_SEGMENT) {
            m_dirty_segment_start = first;
            m_dirty_segment_end = last;
        } else {
            m_dirty_segment_start = std::min(m_dirty_segment_start, first);
            m_dirty_segment_end = std::max(m_dirty_segment_end, last);
        }
    } else {
        m_dirty_segment_start = INVALID_SEGMENT;
        m_dirty_segment_end = INVALID_SEGMENT;
    }
 
    m_geometry_dirty = true;
    m_path_dirty = true;
}
 
LineVertex PathGeneratorNode::get_control_point(size_t index) const
{
    if (index >= m_control_points.size()) {
        MF_ERROR(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Control point index {} out of range (count: {})",
            index, m_control_points.size());
        return {};
    }
 
    return m_control_points[index];
}
 
std::vector<LineVertex> PathGeneratorNode::get_control_points() const
{
    return m_control_points;
}
 
void PathGeneratorNode::clear_path()
{
    m_control_points.clear();
    m_vertices.clear();
    m_draw_window.clear();
    m_draw_vertices.clear();
    m_completed_draws.clear();
    m_path_dirty = true;
    m_needs_layout_update = true;
    m_geometry_dirty = true;
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
}
 
void PathGeneratorNode::set_path_color(const glm::vec3& color, bool force_uniform)
{
    m_current_color = color;
    m_force_uniform_color = force_uniform;
    m_attributes_dirty = true;
    m_path_dirty = true;
 
    if (m_force_uniform_color) {
        for (auto& v : m_completed_draws)
            v.color = color;
 
        for (auto& v : m_draw_vertices)
            v.color = color;
    }
}
 
void PathGeneratorNode::force_uniform_color(bool should_force)
{
    set_path_color(m_current_color, should_force);
}
 
void PathGeneratorNode::set_path_thickness(float thickness, bool force_uniform)
{
    m_current_thickness = thickness;
    m_force_uniform_thickness = force_uniform;
    m_attributes_dirty = true;
    m_path_dirty = true;
 
    if (m_force_uniform_thickness) {
        for (auto& v : m_completed_draws)
            v.thickness = thickness;
 
        for (auto& v : m_draw_vertices)
            v.thickness = thickness;
    }
}
 
void PathGeneratorNode::force_uniform_thickness(bool should_force)
{
    set_path_thickness(m_current_thickness, should_force);
}
 
void PathGeneratorNode::set_interpolation_mode(Kinesis::InterpolationMode mode)
{
    m_mode = mode;
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_path_dirty = true;
    m_geometry_dirty = true;
}
 
void PathGeneratorNode::set_samples_per_segment(Eigen::Index samples)
{
    m_samples_per_segment = samples;
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_geometry_dirty = true;
    m_path_dirty = true;
}
 
void PathGeneratorNode::set_tension(double tension)
{
    m_tension = tension;
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_geometry_dirty = true;
    m_path_dirty = true;
}
 
void PathGeneratorNode::parameterize_arc_length(bool enable)
{
    m_arc_length_parameterization = enable;
    m_dirty_segment_start = INVALID_SEGMENT;
    m_dirty_segment_end = INVALID_SEGMENT;
    m_geometry_dirty = true;
    m_path_dirty = true;
}
 
void PathGeneratorNode::generate_path_vertices()
{
    m_vertices.clear();
 
    const size_t num_points = m_control_points.size();
    if (num_points < 2) {
        return;
    }
 
    if (m_mode == Kinesis::InterpolationMode::LINEAR) {
        generate_direct_path();
    } else if (m_mode == Kinesis::InterpolationMode::CUSTOM && m_custom_func) {
        generate_custom_path();
    } else {
        generate_interpolated_path();
    }
 
    m_path_dirty = true;
}
 
void PathGeneratorNode::generate_direct_path()
{
    m_vertices.reserve(m_control_points.size());
 
    for (const auto& v : m_control_points) {
        glm::vec3 color = m_force_uniform_color ? m_current_color : v.color;
        float thickness = m_force_uniform_thickness ? m_current_thickness : v.thickness;
 
        m_vertices.emplace_back(LineVertex {
            .position = v.position,
            .color = color,
            .thickness = thickness });
    }
}
 
void PathGeneratorNode::generate_custom_path()
{
    const size_t num_points = m_control_points.size();
    size_t total_samples = m_samples_per_segment * (num_points - 1);
 
    m_vertices.resize(total_samples);
 
    for (Eigen::Index i = 0; i < total_samples; ++i) {
        double t = static_cast<double>(i) / static_cast<double>(total_samples - 1);
 
        auto ctrl_idx = std::min<size_t>(static_cast<size_t>(t * float(num_points - 1)), num_points - 1);
        glm::vec3 color = m_force_uniform_color ? m_current_color : m_control_points[ctrl_idx].color;
        float thickness = m_force_uniform_thickness ? m_current_thickness : m_control_points[ctrl_idx].thickness;
 
        m_vertices[i] = LineVertex {
            .position = m_custom_func(m_control_points, t),
            .color = color,
            .thickness = thickness
        };
    }
}
 
void PathGeneratorNode::generate_interpolated_path()
{
    if (m_control_points.size() < 4) {
        return;
    }
 
    const size_t windows = m_control_points.size() - 3;
    const size_t per_window = vertices_per_window();
    const size_t base = m_vertices.size();
 
    m_vertices.resize(base + windows * per_window);
 
    for (size_t w = 0; w < windows; ++w) {
        write_curve_segment(m_control_points, w, m_vertices.data() + base + w * per_window);
    }
}
 
void PathGeneratorNode::regenerate_geometry()
{
    if (!m_geometry_dirty) {
        return;
    }
 
    if (m_dirty_segment_start != INVALID_SEGMENT && m_dirty_segment_end != INVALID_SEGMENT) {
        regenerate_segment_range(m_dirty_segment_start, m_dirty_segment_end);
        m_dirty_segment_start = INVALID_SEGMENT;
        m_dirty_segment_end = INVALID_SEGMENT;
    } else {
        generate_path_vertices();
    }
 
    m_geometry_dirty = false;
    m_path_dirty = true;
}
 
void PathGeneratorNode::regenerate_segment_range(size_t first_window, size_t last_window)
{
    const size_t num_points = m_control_points.size();
    const size_t per_window = vertices_per_window();
 
    if (num_points < 4 || m_vertices.size() != (num_points - 3) * per_window) {
        generate_path_vertices();
        return;
    }
 
    const size_t windows = num_points - 3;
    last_window = std::min(last_window, windows - 1);
 
    for (size_t w = first_window; w <= last_window; ++w) {
        write_curve_segment(m_control_points, w, m_vertices.data() + w * per_window);
    }
}
 
void PathGeneratorNode::compute_frame()
{
    if (m_geometry_dirty) {
        regenerate_geometry();
        m_attributes_dirty = false;
    } else if (m_attributes_dirty) {
        refresh_attributes();
        m_attributes_dirty = false;
        m_path_dirty = true;
    }
 
    if (!m_path_dirty) {
        return;
    }
 
    m_combined_cache.clear();
    m_combined_cache.reserve(m_vertices.size() + m_completed_draws.size() + m_draw_vertices.size());
    m_combined_cache.insert(m_combined_cache.end(), m_vertices.begin(), m_vertices.end());
    m_combined_cache.insert(m_combined_cache.end(), m_completed_draws.begin(), m_completed_draws.end());
    m_combined_cache.insert(m_combined_cache.end(), m_draw_vertices.begin(), m_draw_vertices.end());
 
    if (m_combined_cache.empty()) {
        resize_vertex_buffer(0);
    } else {
        set_vertices<LineVertex>(std::span { m_combined_cache.data(), m_combined_cache.size() });
    }
 
    if (auto layout = get_vertex_layout()) {
        layout->vertex_count = static_cast<uint32_t>(m_combined_cache.size());
        set_vertex_layout(*layout);
    }
 
    m_path_dirty = false;
}
 
void PathGeneratorNode::complete()
{
    if (m_draw_window.size() < 4) {
        MF_WARN(Journal::Component::Nodes, Journal::Context::NodeProcessing,
            "Not enough points in draw window to generate curve segment ({} points)",
            m_draw_window.size());
        m_completed_draws.insert(
            m_completed_draws.end(),
            m_draw_vertices.begin(),
            m_draw_vertices.end());
        m_draw_vertices.clear();
        m_draw_window.clear();
        m_path_dirty = true;
        return;
    }
 
    const size_t per_window = vertices_per_window();
    const size_t windows = m_draw_window.size() - 3;
    const size_t base = m_completed_draws.size();
 
    m_completed_draws.resize(base + windows * per_window);
 
    for (size_t w = 0; w < windows; ++w) {
        write_curve_segment(m_draw_window, w, m_completed_draws.data() + base + w * per_window);
    }
 
    for (size_t i = windows + 1; i < m_draw_window.size(); ++i) {
        append_line_segment(m_draw_window[i - 1], m_draw_window[i], m_completed_draws);
    }
 
    m_draw_vertices.clear();
    m_draw_window.clear();
    m_path_dirty = true;
}
 
} // namespace MayaFlux::Nodes::GpuSync