gui_ui_cache_subsystem.h

Go to the documentation of this file.

#pragma once
 
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <gui_core/gui_id.h>
#include <gui_core/gui_base_types.h>
#include <gui_core/elements/gui_element.h>
 
namespace tachyon
{
 
    class FramePipeline;
    struct FrameContext;
    class ElementStorage;
    class GUIStateManager;
    class ITextSystem;

    class UICacheManager
    {
    public:
        struct Scope
        {
            std::unordered_set<ID> scopeIDs;  
            std::vector<std::pair<ID, int2>> scrollSnapshot;
            std::unordered_set<ID> textEditorIds;
            std::vector<ID> claimedSwatches;

            ID snapHover   = ID::Invalid();
            ID snapActive  = ID::Invalid();
            ID snapFocus   = ID::Invalid();
            ID snapCapture = ID::Invalid();
 
            uint64_t   signature        = 0;   
            ElementRef lastContainerRef = ElementRef::Invalid(); 
            int2       cachedSize {};          
            IntRect    cachedContentBounds {}; 
            bool       hasCachedSize    = false;
            bool       usesPostLayout   = false;
 
            bool     captured        = false; 
            bool     nonCacheable    = false; 
            bool     dirty           = false; 
            bool     missedThisFrame = false; 
            uint64_t firstCaptureFrame = 0;   
 
            ID       parentScopeID = ID::Invalid(); 
            uint64_t themeEpoch    = 0;   
            uint64_t lastUsedFrame = 0;   

            int2  drawCapturePos = {};
        };
 
        UICacheManager(FramePipeline& frame, ElementStorage& storage, GUIStateManager& stateManager);

        Scope& GetOrCreate(ID id);
        Scope* Find(ID id);

        struct HitInput
        {
            bool dragging   = false; 
            bool keyboard   = false; 
            bool rebuildAll = false; 
        };

        bool EvaluateHit(const Scope& s, uint64_t signature, const HitInput& input) const;

        void Invalidate(ID id);

        void InvalidateAll() { m_themeEpoch++; }

        uint64_t CurrentFrame() const { return m_frame; }
        uint64_t ThemeEpoch()   const { return m_themeEpoch; }

        void  SetDrawCacheEnabled(bool e) { m_drawCacheEnabled = e; }
        bool  IsDrawCacheEnabled() const  { return m_drawCacheEnabled; }
        static constexpr float kDrawSettleSecs = 0.15f;
 
        // Per-frame diagnostics, reset at the start of each frame

        void     RecordResult(bool hit) { if (hit) m_frameHits++; else m_frameMisses++; }
        void     RecordDrawReplay()  { m_frameDrawReplays++; }   
        void     RecordDrawCapture() { m_frameDrawCaptures++; }  
        uint32_t FrameHits()         const { return m_frameHits; }
        uint32_t FrameMisses()       const { return m_frameMisses; }
        uint32_t FrameDrawReplays()  const { return m_frameDrawReplays; }
        uint32_t FrameDrawCaptures() const { return m_frameDrawCaptures; }
        size_t   ScopeCount()       const { return m_scopes.size(); }

        static ID MemberOrNull(const Scope& s, ID id)
        {
            return s.scopeIDs.find(id) != s.scopeIDs.end() ? id : ID::Invalid();
        }
 
    private:
        void OnPreFrame();
        void OnPostLayout(ITextSystem* textSystem);
        void OnEndFrame();

        void CaptureScope(Scope& s, ITextSystem* textSystem);
 
        std::unordered_map<ID, Scope> m_scopes;
 
        ElementStorage&  m_storage;
        GUIStateManager& m_stateManager;
 
        uint64_t m_frame      = 0;
        uint64_t m_themeEpoch = 0;
        uint32_t m_frameHits   = 0;
        uint32_t m_frameMisses = 0;
        uint32_t m_frameDrawReplays  = 0;
        uint32_t m_frameDrawCaptures = 0;
        bool     m_drawCacheEnabled = true;

        static constexpr uint64_t kEvictAfterFrames = 240;

        static constexpr uint64_t kSettleFrames = 2;
    };
}