path_fraction()

std::function< float(glm::vec2)> MayaFlux::Kinesis::path_fraction ( std::span< const glm::vec2 >  points, const std::function< glm::vec2()> &  live_offset = {}  )

inline

Normalized arc-length position of the closest point on a polyline.

Inverse to stroke_slider, which places the handle at a fraction of the path's total arc length. Finds the nearest point across all segments and returns its cumulative length divided by the total, so the handle follows the cursor along the path regardless of how far off the path it strays.

Cumulative lengths are computed once and captured; the returned callable allocates nothing per invocation beyond an optional live_offset() call.

Parameters

points	Ordered polyline vertices in NDC. Copied into the closure.
live_offset	Optional. Current translation of the drawn path - shifts the cursor into the path's own frame rather than re-translating every point per call.

Returns

Callable producing a value in [0, 1]. Returns 0 for paths with fewer than two points or zero total length.

Definition at line 176 of file Projection.hpp.

                                                                                         {})
{
    std::vector<glm::vec2> pts(points.begin(), points.end());
    std::vector<float> cumulative(pts.size(), 0.F);
 
    for (size_t i = 1; i < pts.size(); ++i)
        cumulative[i] = cumulative[i - 1] + glm::length(pts[i] - pts[i - 1]);
 
    const float total = pts.empty() ? 0.F : cumulative.back();
 
    return [pts = std::move(pts), cumulative = std::move(cumulative), total, live_offset](
               glm::vec2 p) -> float {
        if (pts.size() < 2 || total <= 0.F)
            return 0.F;
 
        const glm::vec2 shift = live_offset ? live_offset() : glm::vec2(0.F);
        const glm::vec2 q = p - shift;
 
        float best_d2 = std::numeric_limits<float>::max();
        float best_s = 0.F;
 
        for (size_t i = 0; i + 1 < pts.size(); ++i) {
            const glm::vec2 a = pts[i];
            const glm::vec2 ab = pts[i + 1] - a;
            const float len2 = glm::dot(ab, ab);
 
            const float t = len2 > 1e-12F
                ? glm::clamp(glm::dot(q - a, ab) / len2, 0.F, 1.F)
                : 0.F;
 
            const glm::vec2 diff = q - (a + t * ab);
            const float d2 = glm::dot(diff, diff);
 
            if (d2 < best_d2) {
                best_d2 = d2;
                best_s = cumulative[i] + t * std::sqrt(len2);
            }
        }
 
        return std::clamp(best_s / total, 0.F, 1.F);
    };
}

Referenced by MayaFlux::Portal::Forma::Geometry::stroke_slider().

Here is the caller graph for this function: