Image360.h

#pragma once
#include "Resources/Resources.h"
#include "Resources/DataFetcherManager.h"
 
namespace Cogs::Core
{
  class Context;
  struct Image360Component;
}
 
namespace Cogs::Core::Image360
{
  typedef int16_t SlotIx;
 
  // Encoded slot index:
  // - Value >= 0  =>  index in cache with tile data
  // - Value == -1  => tile without data
  // - Value  < -1  => -Value is the offset to the 4 slots that contain the children
  // If less than
 
  typedef int16_t EncodedSlotIx;
  typedef size_t MapIx;
  struct Cache;
 
 
  struct Config {
 
    struct Channel {
      enum struct DataType {
        None,
        SRGB8_JPEG,                           
        SRGB8_PNG,                            
        SRGBA8_PNG,                           
        U16,                                  
        U16_ZST                               
      };
      std::string prefix;
      DataType dataType = DataType::None;
      float scale = 1.f;
      float bias = 0.f;
    };
 
    std::string rootPath;
    uint32_t instanceId = 0;                  
    uint32_t treeDepth = 0;                   
    uint32_t baseSize = 0;                    
    uint32_t noDataDepth = 0;                 
    float extent = 1.f;                       
    uint8_t valueChannel = uint8_t(0);        
    uint8_t depthChannel = static_cast<uint8_t>(~0u);   
    std::vector<Channel> channels;            
 
    // limits
    uint32_t cacheMaxCount = 0;
    uint32_t treeMaxSize = 0;
    uint32_t maxConcurrent = 0;
 
    bool hasDepth = false;                    
    bool discardNoDepth = true;               
 
    bool parseConfigJson(Cogs::FileContents* contents);
  };
 
 
  struct Fetcher
  {
 
    struct LoadItem
    {
      TextureHandle texture = TextureHandle::NoHandle;
      std::unique_ptr<Memory::MemoryBuffer> buffer;
      DataFetcherManager::FetchId fetchId = DataFetcherManager::NoFetchId;
      MapIx mapIx = ~0u;
      SlotIx slotIx = -2;
      uint8_t channelIx = 0;
      uint8_t revision = 0;
      bool failed = false;
    };
 
    std::vector<LoadItem> itemsLoading;
    std::vector<LoadItem> itemsUploading;
 
    bool canLoadAnyItems(const Config& config) const;
 
    void issueChannelFetch(Context* context,
                           const Image360Component& im360Comp,
                           const Config& config,
                           const MapIx mapIx,
                           const SlotIx slotIx,
                           const uint8_t channelIx,
                           const uint8_t revision,
                           const size_t cacheLevel,
                           const size_t cacheLevelIndex);
 
    void processLoadItems(Context* context,
                          const Image360Component& im360Comp,
                          Cache& cache,
                          const Config& config,
                          const uint32_t currentFrame);
 
  private:
    std::vector<LoadItem> itemsLoadingNext; 
  };
 
 
  struct Cache {
 
    struct Item
    {
      enum struct State {
        None,
        Loading,
        Failed,
        Loaded,
        Resident
      };
 
      struct {
        State state = State::None;
      } value, depth;
      MapIx mapIx = ~0u;
      uint32_t lastTouched = 0;
      uint8_t revision = 0;
    };
 
    std::vector<SlotIx> map;
    std::vector<SlotIx> lru;          
    std::vector<Item> items;
    size_t lruPointer = 0;            
    size_t maxItemCount = 512;        
 
    void init(const Config& config);
 
    SlotIx isQuadInCache(Context* context,
                         Fetcher& fetcher,
                         const Image360Component& im360Comp,
                         const Config& config,
                         const uint32_t currentFrame,
                         const size_t cacheLevel,
                         const size_t cacheLevelIndex);
 
    void updateLeastRecentlyUsedList(const uint32_t currentFrame);
 
  };
 
  struct CacheLayout
  {
    uint32_t cols = 0;
    uint32_t rows = 0;
    uint32_t layers = 0;
  };
 
  struct RendererExtensionData
  {
    glm::mat3 worldFromLocal;   // Camera position must be at image origin, so we don't track position
    glm::mat3 localFromWorld;
    Cogs::BufferHandle constants;
    Cogs::TextureHandle encodedTreesTex;
    struct {
      Cogs::TextureHandle tilesTex;
      float scale = 1.f;
      float bias = 0.f;
      uint32_t sampler = 0;
    } value;
    struct {
      Cogs::TextureHandle tilesTex;
      std::vector<std::unique_ptr<Memory::MemoryBuffer>> tilesData;
      float scale = 1.f;
      float bias = 0.f;
      uint32_t sampler = 0;
    } depth;
    CacheLayout cacheLayout;
    uint32_t baseSize = 0;
    uint32_t gpuActiveCacheItemCount = 0;           
    uint32_t gpuAllocatedCacheItemCount = 0;        
    uint32_t currentTreeSize = 0;
    uint32_t noDataDepth = 0;
    bool discardNoDepth = true;
  };
 
 
  struct DynamicLodTree
  {
    struct Quad
    {
      glm::vec3 o;
      glm::vec3 u;
      glm::vec3 v;
      SlotIx slot = -1;
      size_t cacheLevelIndex = 0;
      size_t encodedTreeIndex = 0;
      size_t level = 0;
    };
 
    std::vector<Image360::EncodedSlotIx> data;
 
    void update(Context* context,
                RendererExtensionData& rendererData,
                Fetcher& fetcher,
                Cache& cache,
                const Image360Component& im360Comp,
                const Config& config,
                const uint32_t currentFrame,
                const Image360Component& comp);
 
  private:
    std::vector<Quad> quads, quadsNext; 
  };
 
 
}