RasterSource.h

#pragma once
 
#include "RasterLevel.h"
#include "RasterTile.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include <atomic>
#include <list>
#include <map>
#include <mutex>
#include <unordered_set>
 
namespace Cogs 
{
  struct RasterTileIdentifier;
  struct TileLoadRequest;
 
  struct InvalidationFlags
  {
    enum EInvalidationFlags
    {
      None = 0,
      InvalidateParents = 1 << 0,
    };
  };
 
  struct RasterTileData
  {
    std::vector<uint8_t> data;
    TextureHandle textureHandle = TextureHandle::InvalidHandle;
    TextureFormat format;
    size_t size = 0;
    float minZ;
    float maxZ;
    std::atomic<size_t> generation = 0;
  };
 
  typedef std::lock_guard<RasterSource> ReadLock;
  typedef std::lock_guard<RasterSource> WriteLock;
  
  // Use after rewrite:
  //typedef std::shared_lock<RasterSource> ReadLock;
  //typedef std::lock_guard<RasterSource> WriteLock;
 
  class RasterSource
  {
  public:
    virtual ~RasterSource();
 
    std::vector<RasterLevel> & getLevels() { return levels; }
    const std::vector<RasterLevel> & getLevels() const { return levels; }
    
    int getTileWidth() const { return tileLongitudePosts; }
    int getTileHeight() const { return tileLatitudePosts; }
    
    virtual void requestTile(const TileLoadRequest & request) = 0;
 
    void lock() { readyMutex.lock(); }
    void unlock() { readyMutex.unlock(); }
 
    TextureHandle loadTexture(const unsigned char * data, const int width, const int height, const TextureFormat format, const size_t size);
    void releaseTexture(TextureHandle texture, const size_t size);
 
    RasterTile * getTile(const RasterTileIdentifier & identifier);
    RasterTile * getTile(const size_t id);
 
    void loadTileData(RasterTile * tile, size_t requestGeneration, std::vector<uint8_t> & data, TextureHandle textureHandle, TextureFormat format, size_t size);
 
    void invalidateTile(const RasterTileIdentifier & id, InvalidationFlags::EInvalidationFlags flags = InvalidationFlags::InvalidateParents);
 
    void cancelActiveRequests();
 
    void purgeCache();
 
    void purgeResidentCache();
 
    void purgeOldData();
 
    void releaseTileData(RasterTileData & tileData);
 
    bool tryGetTextureHandle(const RasterTile * tile, TextureHandle & handle);
 
    void updateTileUsage(const RasterTile * tile);
    void refTile(RasterTile * tile);
    void unrefTile(RasterTile * tile);
 
    void removeTileUsageData(size_t code);
    void removeTile(RasterTile * tile);
    void evictLruTile();
 
    RasterTileData * getTileData(RasterTile * tile);
 
    virtual void allocateTileStorage(const size_t textureSize, std::vector<uint8_t> & buffer) = 0;
    virtual void deallocateTileStorage(std::vector<uint8_t> & buffer) = 0;
 
    void addSubscriber(struct RasterSourceSubscription * handler) { subscribers.insert(handler); }
    void removeSubscriber(struct RasterSourceSubscription * handler) { subscribers.erase(handler); }
 
    bool hasProcessingRequests() const { return processing.getCount() > 0; }
 
    struct Processing
    {
      void lock() { ++count; }
      void unlock() { --count; }
      size_t getCount() const { return count.load(); }
 
    private:
      std::atomic<size_t> count = 0;
    } processing;
 
    std::unordered_set<struct RasterSourceSubscription *> subscribers;
    std::mutex subscriberMutex;
 
    IGraphicsDevice * device = nullptr;
 
    std::atomic<size_t> textureBufferSize = 0;
 
    TextureFormat format = TextureFormat::Unknown;
 
    bool isHeight = false;
 
    float minZ = 0;
    float maxZ = 0;
 
    std::string name;
 
    std::atomic<size_t> generation = 0;
 
  protected:
    std::vector<RasterLevel> levels;
 
    int tileLongitudePosts = 0;
    int tileLatitudePosts = 0;
 
    TextureHandle invalidTileHandle;
 
  private:
    std::map<size_t, RasterTile> activeTiles;
    std::map<size_t, RasterTileData> residentTiles;
    std::vector<RasterTileData> oldTileData;
 
    std::list<size_t> lruList;
    std::map<size_t, std::list<size_t>::iterator> lruMap;
 
    std::mutex readyMutex;
  };
}