BaseRasterSource.h

#pragma once
 
#include "../Bridge/TerrainProviderFunctions.h"
 
#include "Services/TaskManager.h"
 
#include "Rendering/DataFormat.h"
 
#include "Foundation/Collections/IntrusiveList.h"
#include "Foundation/Collections/Pool.h"
#include "Foundation/Platform/Threads.h"
 
#include <glm/glm.hpp>
 
#include <unordered_set>
 
namespace Cogs::Core {
  class Context;
}
 
namespace Cogs::Core::TerrainProvider {
 
  struct Extent {
    glm::dvec2 min{ 0.f };
    glm::dvec2 max{ 0.f };
  };
 
  struct Tiling {
    glm::dvec2 size;
    unsigned width = 256;
    unsigned height = 256;
    unsigned overlapStart = 0;
    unsigned overlapEnd = 0;
    unsigned levels = 1;
  };
 
  struct CoordSys
  {
    enum struct Kind {
      EPSG
    } kind = Kind::EPSG;
    unsigned id = 4326;
  };
 
  struct BaseConfig
  {
    virtual ~BaseConfig() {}
 
    virtual bool compatible(const BaseConfig* other) const;
 
    Extent extent;
    Tiling tiling;
    CoordSys coordsys;
    TextureFormat textureFormat = TextureFormat::Unknown;
    MimeType mimeType = MimeType::None;
    StringRef cacheKey = NoString;
    StringRef name = NoString;
    float noData = std::numeric_limits<float>::quiet_NaN();
    bool offline = false;
  };
 
  struct TileId
  {
    unsigned level = 0;
    unsigned i = 0;
    unsigned j = 0;
  };
 
  bool equal(const TileId& id_a, const TileId& id_b);
 
  struct Request : IntrusiveNode
  {
    TileLoadCallback* loadCallback = nullptr;
    void* loadData = nullptr;
    TileId id;
    TaskId task = NoTask;
    bool failure = false;
  };
 
  uint64_t tileKey(const TileId& id);
 
  class ICache
  {
  public:
    virtual ~ICache() {}
 
    virtual bool getTile(Memory::MemoryBuffer& contents, MimeType& kind, const TileId& id) = 0;
 
    virtual bool storeTile(const Memory::MemoryBuffer& contents, MimeType kind, const TileId& id, StringView debugLog) = 0;
 
  };
 
  class BaseRasterSource : public IRasterSource
  {
    friend class HandleRequestTask;
  public:
    BaseRasterSource(Context* context);
    virtual ~BaseRasterSource();
    Cogs::RasterSourceParameters getParameters() const override;
    const CoordSys& getCoordSys() const { return coordsys; }
    ErrorCode getErrorCode() const final;
    void setErrorCode(ErrorCode newErrorCode);
 
  protected:
    bool init(const BaseConfig& conf, std::unique_ptr<ICache>&& icache);
    void getConfig(BaseConfig& conf) const;
    void addTile(const Cogs::Memory::MemoryBuffer& contents, MimeType kind, Request* req, StringView debugLog);
    void addTileFailure(Request* req, StringView debugLog);
    virtual void requestTile(Request* req) = 0;
 
    Context* context = nullptr;
    Extent extent;
    Tiling tiling;
    CoordSys coordsys;
    TextureFormat textureFormat = TextureFormat::Unknown;
    StringRef name = NoString;
    float noDataValue = std::numeric_limits<float>::quiet_NaN();
    bool emitDebugLog = true;
 
  private:
    std::unique_ptr<ICache> cache;
    class StashService* stashService = nullptr;
 
    // Request life-time:
    //
    // - Terrain engine invokes tileRequestCallbackFunc to request a tile:
    //   - Check requests.inflight to check if we already have a request for this tile, if yes, do nothing.
    //   - Create a new request
    //   - Insert tile id into inFlight
    //   - Insert into hasHandleTask
    //   - Issue HandleRequestTask
    //
    //  - HandleRequestTask:
    //    - If tile is failure or tile is in cache:
    //      - Provide tile to terrain engine, data if in cache, nullptr if failure
    //      - Remove request from requests.inFlight
    //      - Remove request from requests.hasHandleTask
    //      - Destroy request and then exit
    //    - If tile is not in cache:
    //      - Remove request from requests.inFlight
    //      - Insert request into requests.waitingForProvider
    //      - Invoke provider's requestTile
    //
    //  - Provider's request tile must either invoke addTile or addTileFailure
    //    - If addTileFailure, set failure to true
    //    - Stores tile in cache
    //    - Removes request from request.waitingForProvider
    //    - Insert into hasHandleTask
    //    - Issue HandleRequestTask
    struct {
      Cogs::Mutex mutex;
      Cogs::Collections::Pool<Request> store;
      std::unordered_set<uint64_t> inFlight;
      IntrusiveList hasHandleTask;
      IntrusiveList waitingForProvider;
    } requests;
 
    struct {
      mutable Cogs::Mutex mutex;
      ErrorCode errorCode = ErrorCode::NoError;
    } state;
 
    static bool tileRequestCallbackFunc(void* userData, TileLoadCallback tileLoadCallback, int level, int x, int y);
 
  };
 
}