gui_transition_manager.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_easing.h>
#include <gui_core/gui_id.h>
 
#include <optional>
#include <stdint.h>
#include <unordered_map>
 
namespace tachyon
{
 
    enum class ElementState : uint8_t;
    enum class VisualBoxStyleIndex : uint16_t;

    struct TransitionState
    {
        uint32_t fromStyleIndex = 0;
        uint32_t toStyleIndex   = 0;
        float    blendT         = 1.0f; 
    };

    struct TransitionTiming
    {
        float       duration = 0.0f;              
        CubicBezier easing   = Easing::EaseOut;
 
        bool operator==(const TransitionTiming&) const = default;
    };

    uint32_t ComputeGPUStyleIndex(VisualBoxStyleIndex base, ElementState state);

    class TransitionManager
    {
    public:
        // Each kind of change has its own timing; the ones not listed (press, selection,
        // disabled) are instant.
        static constexpr TransitionTiming kHoverIn  { 0.070f, Easing::EaseOut };
        static constexpr TransitionTiming kHoverOut { 0.140f, Easing::EaseOut };
        static constexpr TransitionTiming kRelease  { 0.120f, Easing::EaseOut };
        static constexpr TransitionTiming kFocus    { 0.100f, Easing::EaseOut };
        static constexpr TransitionTiming kToggle   { 0.120f, Easing::EaseInOut }; 
        static constexpr TransitionTiming kInvalid  { 0.150f, Easing::EaseOut };   

        static TransitionTiming TimingFor(ElementState fromState, ElementState toState);

        struct Blend
        {
            ElementState fromState;
            ElementState toState;
            float        t; 
        };

        void OnStateChange(ID id, ElementState fromState, ElementState toState, float elapsedSecs);
        void OnStateChange(ID id, ElementState fromState, ElementState toState,
                           TransitionTiming timing, float elapsedSecs);

        void OnStateSeen(ID id, ElementState state, ElementState watched, float elapsedSecs);
        bool IsWatched(ID id) const { return !m_seen.empty() && m_seen.contains(id); }

        std::optional<Blend> Find(ID id, float elapsedSecs) const;

        TransitionState Resolve(ID id, VisualBoxStyleIndex base,
                                ElementState currentState, float elapsedSecs) const;

        void Purge(float elapsedSecs);

        void Clear() { m_transitions.clear(); m_seen.clear(); }

        void SetEnabled(bool enabled) { m_enabled = enabled; if (!enabled) Clear(); }
        bool IsEnabled() const { return m_enabled; }

        void SetReducedMotion(bool reduced) { m_reducedMotion = reduced; if (reduced) m_transitions.clear(); }
        bool IsReducedMotion() const { return m_reducedMotion; }
 
    private:
        struct TransitionEntry
        {
            ElementState     fromState;
            ElementState     toState;
            float            startTime; 
            TransitionTiming timing;
        };
        struct Seen
        {
            ElementState state;     
            uint32_t     frame;     
        };
 
        std::unordered_map<ID, TransitionEntry> m_transitions;
        std::unordered_map<ID, Seen>            m_seen;
        uint32_t m_frame         = 0;
        bool     m_enabled       = true;
        bool     m_reducedMotion = false;
    };

} // namespace tachyon