angle_fraction() [2/2]

std::function< float(glm::vec2)> MayaFlux::Kinesis::angle_fraction ( glm::vec2  center, float  angle_start, float  angle_end, const std::function< glm::vec2()> &  live_offset = {}  )

inlinenoexcept

Fraction along an angular sweep about center.

Inverse to radial, which places the indicator at angle_start + value * (angle_end - angle_start). Handles sweeps in either direction and sweeps crossing the atan2 discontinuity. The cursor's distance from the centre is ignored, so the control remains responsive outside the drawn radius, which is what a knob gesture expects.

Angles outside the sweep fall in a dead zone and snap to whichever end is nearer, so a knob dragged past its minimum stays at 0 instead of jumping to 1.

Points at the exact centre return zero rather than an undefined angle.

Parameters

center	Sweep centre in NDC.
angle_start	Angle in radians corresponding to value 0.
angle_end	Angle in radians corresponding to value 1.
live_offset	Optional. Current translation of the drawn control.

Returns

Callable producing a value in [0, 1].

Definition at line 111 of file Projection.hpp.

                                                {}) noexcept
{
    const float delta = angle_end - angle_start;
 
    return [center, angle_start, delta, live_offset](glm::vec2 p) -> float {
        constexpr float k_two_pi = 6.283185307179586F;
 
        if (std::abs(delta) < 1e-6F)
            return 0.F;
 
        const glm::vec2 shift = live_offset ? live_offset() : glm::vec2(0.F);
        const glm::vec2 d = (p - shift) - center;
        if (glm::dot(d, d) < 1e-12F)
            return 0.F;
 
        float rel = std::fmod(std::atan2(d.y, d.x) - angle_start, k_two_pi);
        if (delta > 0.F && rel < 0.F) {
            rel += k_two_pi;
        } else if (delta < 0.F && rel > 0.F) {
            rel -= k_two_pi;
        }
 
        const float travelled = std::abs(rel);
        const float sweep = std::abs(delta);
        const float gap = k_two_pi - sweep;
        if (travelled <= sweep || gap <= 0.F)
            return std::clamp(travelled / sweep, 0.F, 1.F);
 
        return (travelled - sweep) < gap * 0.5F ? 1.F : 0.F;
    };
}

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

Here is the caller graph for this function: