gui_gradient_manager.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/style/gui_style.h>
 
#include <stdint.h>
#include <vector>
#include <span>
#include <unordered_map>
 
namespace tachyon
{
 
    class Image;
    class GraphicsContext;

    struct GradientHandle
    {
        uint32_t value = 0; 
 
        constexpr GradientHandle() = default;
        constexpr explicit GradientHandle(uint32_t v) : value(v) {}

        constexpr bool IsValid() const { return value != 0; }
        constexpr uint32_t SlotIndex() const { return value >> 8; } 
        constexpr uint8_t  Generation() const { return value & 0xFF; } 
 
        constexpr bool operator==(const GradientHandle&) const noexcept = default;
 
        static constexpr GradientHandle Invalid() { return GradientHandle(0); } 
        static constexpr GradientHandle Make(uint32_t slotIndex1Based, uint8_t generation)
        {
            return GradientHandle((slotIndex1Based << 8) | uint32_t(generation));
        }
    };

    struct AtlasLocation
    {
        uint16_t col   = 0; 
        uint16_t row   = 0; 
        uint16_t width = 0; 
        uint8_t  page  = 0; 
    };

    class GradientManager
    {
    public:
        static constexpr uint32_t kMaxPageHeight = 8192;

        static constexpr int32_t kUnregisteredPage = -1;
 
    public:
        GradientManager(size_t width = 256);

        void ReleaseAll(GraphicsContext* graphicsContext);

        GradientHandle AcquireSolidColor(const color4b& color);
        GradientHandle AcquireSolidColor(const color4f& color);
 
        GradientHandle AcquireColors(const color4b& c0, const color4b& c1);
        GradientHandle AcquireColors(const color4f& c0, const color4f& c1);
 
        GradientHandle AcquireColors(const color4b& c0, const color4b& c1, const color4b& c2);
        GradientHandle AcquireColors(const color4f& c0, const color4f& c1, const color4f& c2);
 
        GradientHandle AcquireColors(const color4b& c0, const color4b& c1, const color4b& c2, const color4b& c3);
        GradientHandle AcquireColors(const color4f& c0, const color4f& c1, const color4f& c2, const color4f& c3);
 
        GradientHandle AcquireGradient(const Gradient& g);

        void AddRef(GradientHandle handle);
        bool Release(GradientHandle handle);

        AtlasLocation GetLocation(GradientHandle handle) const;

        bool IsValid(GradientHandle handle) const;

        uint16_t GetRefcount(GradientHandle handle) const;

        inline size_t Width() const noexcept { return m_width; }

        inline uint32_t PageCount() const noexcept { return static_cast<uint32_t>(m_pages.size()); }

        size_t PageHeight(uint32_t pageIndex) const noexcept;

        std::span<const color4b> PageTextureData(uint32_t pageIndex) const noexcept;

        std::span<color4b> PageTextureData(uint32_t pageIndex) noexcept;
        void MarkPageModified(uint32_t pageIndex) noexcept;

        int32_t GetPagePhysicalImageIndex(uint32_t pageIndex) const noexcept;
        void SetPagePhysicalImageIndex(uint32_t pageIndex, int32_t shaderSlotZeroBased) noexcept;
        bool HasPageTableChanged() const noexcept { return m_pageTableDirty; }
        void ClearPageTableChanged() noexcept { m_pageTableDirty = false; }

        void ClearAll() noexcept;

        tachyon::Image* GetGradientImage(GraphicsContext* graphicsContext, uint32_t pageIndex = 0);
 
    private:
        struct Slot
        {
            uint64_t contentHash = 0; 
            uint16_t refcount = 0;    
            uint16_t row = 0;
            uint16_t col = 0;
            uint16_t width = 0;       
            uint8_t  page = 0;
            uint8_t  generation = 0;  
            bool     inUse = false;
        };
 
        struct Page
        {
            uint32_t width = 0;
            uint32_t height = 0;              
            uint32_t rowsUsed = 0;            
            std::vector<color4b> data;         
            Image* image = nullptr;
            bool modified = true;

            int32_t smallRow = -1;
            int32_t smallCursor = 0;           
 
            int32_t physicalImageIndex = kUnregisteredPage; 
        };
 
        // --- helpers ---
        GradientHandle AcquireSmall(uint16_t width, uint64_t contentHash,
                                    const color4b* colors);
        GradientHandle AcquireRow(uint64_t contentHash,
                                  std::span<const color4b> rowPixels);

        int32_t AllocateSmallSlot(uint16_t width);
        int32_t AllocateRowSlot();
 
        uint32_t AllocateSlotStorage();    // returns slot index (into m_slots)
        void     FreeSlotStorage(uint32_t slotIdx);
 
        bool GrowOrAddPage(uint32_t& outPageIdx, uint32_t& outRow);   // for full-row allocs
        bool EnsureSmallRowAvailable(uint32_t& outPageIdx, uint16_t width);
 
        Slot* GetSlot(GradientHandle handle);
        const Slot* GetSlot(GradientHandle handle) const;
 
        void ReleaseSlot(uint32_t slotIdx);
 
        static uint64_t HashGradient(const Gradient& g);
        static uint64_t HashSmall(uint16_t width, const color4b* colors);
 
        size_t                      m_width;
        std::vector<Page>           m_pages;
        std::vector<Slot>           m_slots;
        std::vector<uint32_t>       m_freeSlotStorage; 

        static constexpr uint32_t kFreeListCount = 6;
        std::vector<uint32_t>       m_freeLists[kFreeListCount]; 

        std::unordered_map<uint64_t, uint32_t> m_contentDedup;
 
        bool m_pageTableDirty = true; 
    };

}