TexAtlasSystem.h

#pragma once
#include "Systems/ComponentSystem.h"
#include "TexAtlasComponent.h"
 
namespace Cogs::Core::TexAtlas
{
  using SlotIx = uint16_t;
  static constexpr SlotIx NoSlotIx = static_cast<SlotIx>(~0u);
 
  using TreeIx = uint64_t;
  static constexpr TreeIx NoTreeIx = ~static_cast<TreeIx>(0u);
 
  struct Cache;
  struct Geometry;
 
  struct Layout
  {
    glm::ivec2 offset;    
    glm::uvec2 size;      
    uint32_t tileScale;   
    uint32_t level;       
    uint32_t maxLevel;    
  };
 
  struct Fetcher
  {
    struct LoadItem
    {
      size_t pathHash = 0;
      TextureHandle texture = TextureHandle::NoHandle;
      TreeIx treeIx = NoTreeIx;
      SlotIx slotIx = NoSlotIx;
    };
 
    struct UrlBuilderOp
    {
      enum struct Kind
      {
        InsertChars,
        InsertX,
        InsertY,
        InsertZ,
        InsertXMin,
        InsertYMin,
        InsertXMax,
        InsertYMax
      };
      Kind kind;
      std::string_view chars;
    };
 
    std::string url;
    std::vector<UrlBuilderOp> urlBuilder;
    std::vector<LoadItem> loaded;   // Items that has finished loading and can be stored in atlas.
    std::vector<LoadItem> loading;  // Items that are currently loading.
    std::vector<LoadItem> tmp;      // Temp array used when filtering loaditems
 
    uint32_t currentFrame = 0;
    uint32_t currentTime = 0;
    uint32_t timeout = 0;
    uint32_t issuedThisFrame = 0;
 
    uint32_t maxQueueSize = 10;
    uint32_t maxIssuesPerFrame = 3;
 
    uint32_t tileWidth = 0;         // Set by the first tile that is succesfully fetched and will kept fixed thereafter.
    uint32_t tileHeight = 0;
 
    glm::dvec2 datasetExtentMin;
    glm::dvec2 datasetExtentMax;
 
    void update(Context* context, uint32_t currentFrame, uint32_t currentTime, uint32_t timeout, std::string_view urlTemplate);
 
    void processLoadQueue(Context* context, Cache& cache);
 
    bool canFetch() const;
 
    void issueFetch(Context* context,
                    const glm::uvec3& tileId,
                    TreeIx treeIx,
                    SlotIx slotIx);
  };
 
  struct Cache
  {
    struct Slot
    {
      enum struct State
      {
        None,
        Loading,
        Failed,
        Cancelled,
        Loaded
      };
      State state = State::None;
      TreeIx treePos = NoTreeIx;
      uint32_t lastTouched = 0;
      uint32_t stateChangeTime = 0;
      uint8_t revision = 0;
      uint8_t retries = 0;
    };
 
    uint32_t currentFrame = 0;
    uint32_t currentTime = 0;
    std::unordered_map<TreeIx, SlotIx> tree;
    std::vector<SlotIx> lru;          
    std::vector<Slot> slots;
 
    uint32_t lruPointer = 0;          
    uint32_t maxItemCount = 0;        
    uint32_t minRetryDelay = 0;       
 
    void setStateNone(Slot& slot) { slot.stateChangeTime = currentTime; slot.state = Slot::State::None; slot.retries = 0; }
    void setStateLoading(Slot& slot) { slot.stateChangeTime = currentTime; slot.state = Slot::State::Loading; }
    void setStateFailed(Slot& slot) { slot.stateChangeTime = currentTime; slot.state = Slot::State::Failed; }
    void setStateCancelled(Slot& slot) { slot.stateChangeTime = currentTime; slot.state = Slot::State::Cancelled; slot.retries = 0; }
    void setStateLoaded(Slot& slot) { slot.stateChangeTime = currentTime; slot.state = Slot::State::Loaded; slot.retries = 0; }
 
    void update(uint32_t currentFrame, uint32_t currentTime, uint32_t minRetryDelay, uint32_t maxItemCount);
 
    SlotIx getOrAllocCacheSlot(Context* context, Fetcher& fetcher, const glm::uvec3& tileId);
  };
 
  struct LodTree
  {
    struct Tile
    {
      float error;
      int32_t x;
      int32_t y;
      uint8_t level;
      uint16_t encodedIx;
      SlotIx slotIx;
    };
 
    std::vector<Tile> candidates;
    std::vector<Tile> tiles;
    std::vector<uint16_t> encoded;
 
    void update(Context* context, const Geometry& geo, Cache& cache, Fetcher& fetcher, const Layout& layout, float tolerance, bool restrictBetweenNearAndFar, bool lodFreeze);
  };
 
  struct Geometry
  {
    glm::dvec2 domain[2] = {};
    glm::vec2 invDomainMapShift = glm::vec2(0.f);
    glm::vec2 invDomainMapScale = glm::vec2(0.f);
    glm::vec2 coefficients[4] = {};   
    float elevationMin = 0.f;
    float elevationMax = 0.f;
 
    void calcTileCorners(glm::vec4* corners, const LodTree::Tile& tile) const;
  };
 
  struct TrackedMaterial
  {
    MaterialHandle material;            // Handle to keep material alive.
    uint32_t lastSeen = 0;
    TexAtlasComponent* slots[4] = {};
  };
 
  struct MaterialKeys
  {
    std::string level;
    std::string floatCoeffs;
    std::string intCoeffs;
    std::string tile;
    std::string tree;
  };
 
}
 
namespace Cogs::Core
{
  struct TexAtlasRenderer;
 
  struct TexAtlasData
  {
    TextureHandle treeTex;
    size_t treeHashValue = 0;
    TextureHandle tilesTex;
    TextureHandle tilesOldTex;  // Previous texture when resizing
 
    TexAtlas::Geometry geometry;
    TexAtlas::Layout layout;
    TexAtlas::Fetcher fetcher;
    TexAtlas::Cache cache;
    TexAtlas::LodTree tree;
 
    glm::mat4 floatCoefficients;
    glm::ivec4 intCoefficients;
    int32_t levels = 0;
 
    bool inUse = false; // Hook for twin-visuals texatlas task to enable this outside of material use
  };
 
  struct TexAtlasSystem : public ComponentSystemWithDataPool<TexAtlasComponent, TexAtlasData>
  {
    using base = ComponentSystemWithDataPool<TexAtlasComponent, TexAtlasData>;
 
    TexAtlasSystem(Memory::Allocator* allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
    void initialize(Context* context) override;
 
    ComponentHandle createComponent() override;
 
    void destroyComponent(ComponentHandle component) override;
 
    void update(Context* context) override;
 
    TexAtlasRenderer* renderer = nullptr;
 
 
    std::unordered_map<Material*, TexAtlas::TrackedMaterial> trackedMaterials;
 
    std::vector<TexAtlas::MaterialKeys> materialKeys;
  };
 
}