stroke_slider()

MAYAFLUX_API Form< float > MayaFlux::Portal::Forma::Geometry::stroke_slider	(	std::span< const glm::vec2 >	path,
		FormaTarget	handle_buf,
		float	half_thickness = 0.02F,
		glm::vec3	track_color = glm::vec3(0.3F),
		glm::vec3	fill_color = glm::vec3(0.2F, 0.6F, 1.0F),
		glm::vec3	handle_color = glm::vec3(0.95F),
		float	handle_size = 10.0F,
		const std::function< glm::vec2()> &	live_offset = {}
	)

Geometry function for a value scrubber along an arbitrary polyline.

Value in [0, 1] maps to arc-length position along path. The full path is rendered as a LINE_LIST in track_color; the prefix from the path start to the handle position is rendered in fill_color. The handle itself is a PointVertex submitted to handle_buf each sync.

Parameters

path	Ordered polyline vertices in NDC. Copied into closure.
handle_buf	POINT_LIST FormaBuffer for the handle point. Must be registered and have setup_rendering called.
half_thickness	Hit region half-thickness in NDC units.
track_color	Color of the full path.
fill_color	Color of the prefix segment up to the handle.
handle_color	Color of the handle point.
handle_size	Handle point size in pixels.
live_offset	Optional. Current translation of the drawn path.

Definition at line 185 of file FormFactory.cpp.

{
    std::vector<glm::vec2> pts(path.begin(), path.end());
 
    std::vector<float> seg_lengths;
    seg_lengths.reserve(pts.size() > 0 ? pts.size() - 1 : 0);
    float total_len = 0.0F;
    for (size_t i = 0; i + 1 < pts.size(); ++i) {
        float l = glm::length(pts[i + 1] - pts[i]);
        seg_lengths.push_back(l);
        total_len += l;
    }
 
    Kinesis::AABB2D aabb { .min = pts.empty() ? glm::vec2(0.F) : pts[0],
        .max = pts.empty() ? glm::vec2(0.F) : pts[0] };
    for (const auto& p : pts) {
        aabb.min = glm::min(aabb.min, p);
        aabb.max = glm::max(aabb.max, p);
    }
    aabb = aabb.expanded(half_thickness);
 
    auto project = Kinesis::path_fraction(path, live_offset);
    const size_t cap = pts.size() * 4 * sizeof(Kakshya::LineVertex);
 
    GeometryFn<float> fn = [pts = std::move(pts),
                               seg_lengths = std::move(seg_lengths),
                               total_len,
                               aabb,
                               handle_buf = std::move(handle_buf),
                               half_thickness,
                               track_color,
                               fill_color,
                               handle_color,
                               handle_size,
                               live_offset](float v, std::vector<uint8_t>& out, Element& el) {
        if (pts.size() < 2) {
            out.clear();
            return;
        }
 
        const glm::vec2 shift = live_offset ? live_offset() : glm::vec2(0.F);
 
        const float target = std::clamp(v, 0.0F, 1.0F) * total_len;
 
        // Arc-length interpolation is translation-invariant. It is computed
        // in pts' own (unshifted) frame, and the shift is applied once to
        // the result.
        glm::vec2 handle_pos = pts.front();
        float accumulated = 0.0F;
        size_t split_seg = 0;
        float split_t = 0.0F;
        for (size_t i = 0; i < seg_lengths.size(); ++i) {
            if (accumulated + seg_lengths[i] >= target || i + 1 == seg_lengths.size()) {
                split_t = seg_lengths[i] > 0.0F
                    ? (target - accumulated) / seg_lengths[i]
                    : 0.0F;
                split_t = std::clamp(split_t, 0.0F, 1.0F);
                handle_pos = glm::mix(pts[i], pts[i + 1], split_t);
                split_seg = i;
                break;
            }
            accumulated += seg_lengths[i];
        }
        handle_pos += shift;
 
        std::vector<glm::vec2> live_pts;
        live_pts.reserve(pts.size());
        for (const auto& p : pts)
            live_pts.push_back(p + shift);
 
        auto verts = Kinesis::polyline(live_pts, track_color);
 
        auto fill = Kinesis::polyline(
            std::span<const glm::vec2>(live_pts).subspan(0, split_seg + 1),
            fill_color);
        verts.insert(verts.end(), fill.begin(), fill.end());
 
        if (split_t > 0.0F) {
            verts.push_back({ .position = { live_pts[split_seg].x, live_pts[split_seg].y, 0.0F }, .color = fill_color });
            verts.push_back({ .position = { handle_pos.x, handle_pos.y, 0.0F }, .color = fill_color });
        }
 
        write_verts(out, verts);
 
        el.bounds_hint = aabb.translated(shift);
        el.contains = Kinesis::stroke_bounds(live_pts, half_thickness);
 
        if (handle_buf) {
            Kakshya::PointVertex hv {
                .position = { handle_pos.x, handle_pos.y, 0.0F },
                .color = handle_color,
                .size = handle_size,
            };
            std::vector<uint8_t> hbytes(sizeof(hv));
            std::memcpy(hbytes.data(), &hv, sizeof(hv));
            handle_buf.submit(hbytes);
        }
    };
 
    return { std::move(fn),
        Graphics::PrimitiveTopology::LINE_LIST,
        cap,
        drag_with<float>(std::move(project)) };
}

References MayaFlux::Kinesis::AABB3D::contains(), MayaFlux::Kinesis::AABB3D::expanded(), MayaFlux::Portal::Graphics::LINE_LIST, MayaFlux::Kinesis::AABB3D::max, MayaFlux::Kinesis::AABB3D::min, out, MayaFlux::Kinesis::path_fraction(), MayaFlux::Kinesis::polyline(), MayaFlux::Kakshya::PointVertex::position, MayaFlux::Kinesis::stroke_bounds(), MayaFlux::Kinesis::AABB3D::translated(), and write_verts().

Here is the call graph for this function: