RasterSource.cpp

#include "RasterSource.h"
 
#include "RasterTile.h"
 
#include "Rendering/ITextures.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RasterSource");
}
 
Cogs::RasterSource::~RasterSource()
{
  for (auto & r : residentTiles) {
    auto & tileData = r.second;
 
    if (HandleIsValid(tileData.textureHandle) && tileData.textureHandle != invalidTileHandle) {
      releaseTexture(tileData.textureHandle, tileData.data.size());
    }
  }
 
  if (HandleIsValid(invalidTileHandle)) {
    releaseTexture(invalidTileHandle, 0);
  }
}
 
Cogs::RasterTile * Cogs::RasterSource::getTile(const RasterTileIdentifier & identifier)
{
  if (static_cast<size_t>(identifier.level) > getLevels().size() - 1) {
    return nullptr;
  }
 
  const size_t hashCode = identifier.getHashCode();
  auto tileIt = activeTiles.find(hashCode);
 
  if (tileIt == activeTiles.end()) {
    auto & level = levels[identifier.level];
    auto & tile = activeTiles[hashCode];
 
    tile.identifier = identifier;
    tile.extent.west = identifier.x * level.getLongitudePostsPerTile();
    tile.extent.east = std::min(tile.extent.west + level.getLongitudePostsPerTile(), level.getLongitudePosts()) - 1;
    tile.extent.south = identifier.y * level.getLatitudePostsPerTile();
    tile.extent.north = std::min(tile.extent.south + level.getLatitudePostsPerTile(), level.getLatitudePosts()) - 1;
    tile.flags |= level.isTileIndexValid(identifier.x, identifier.y) ? TileFlags::None : TileFlags::OutOfBounds;
 
    return &tile;
  } else {
    return &tileIt->second;
  }
}
 
Cogs::RasterTile * Cogs::RasterSource::getTile(const size_t id)
{
  auto i = activeTiles.find(id);
 
  if (i != activeTiles.end()) {
    return &i->second;
  }
  return nullptr;
}
 
bool Cogs::RasterSource::tryGetTextureHandle(const RasterTile * tile, TextureHandle & textureHandle)
{
  if (tile->data) {
    updateTileUsage(tile);
 
    textureHandle = tile->data->textureHandle;
 
    return true;
  }
 
  return false;
}
 
void Cogs::RasterSource::updateTileUsage(const RasterTile * tile)
{
  // We do not want to track the invalid tiles in the LRU.
  if (tile->isOOB()) return;
 
  // Referenced tiles are excluded from LRU tracking.
  if (tile->usage != 0) return;
 
  auto code = tile->identifier.getHashCode();
 
  // Update tile usage status to avoid cache eviction
  auto lruIt = lruMap.find(code);
  if (lruIt != lruMap.end()) {
    lruList.erase(lruIt->second);
  }
 
  // We move the current tile to the front of the list.
  lruList.push_front(code);
  lruMap[code] = lruList.begin();
}
 
void Cogs::RasterSource::refTile(RasterTile * tile)
{
  tile->usage++;
 
  // Stop tracking the LRU state of the tile as long as it is referenced, avoiding the 
  // tile being evicted during query operations.
  auto code = tile->identifier.getHashCode();
  auto lruIt = lruMap.find(code);
  if (lruIt != lruMap.end()) {
    lruList.erase(lruIt->second);
    lruMap.erase(code);
  }
}
 
void Cogs::RasterSource::unrefTile(RasterTile * tile)
{
  assert(tile->usage && "Count should not be zero or less when dereferencing a tile.");
 
  if (--tile->usage == 0) {
    updateTileUsage(tile);
  }
}
 
void Cogs::RasterSource::removeTile(RasterTile * tile)
{
  deallocateTileStorage(tile->data->data);
 
  residentTiles.erase(tile->identifier.getHashCode());
 
  tile->data = nullptr;
}
 
void Cogs::RasterSource::removeTileUsageData(size_t code)
{
  lruList.pop_back();
  lruMap.erase(code);
}
 
void Cogs::RasterSource::evictLruTile()
{
  if (!lruList.size()) return;
 
  size_t code = lruList.back();
 
  assert(lruMap[code] == (--lruList.end()));
 
  removeTileUsageData(code);
 
  auto tile = getTile(code);
  
  releaseTileData(*tile->data);
 
  removeTile(tile);
}
 
void Cogs::RasterSource::loadTileData(RasterTile * tile, size_t requestGeneration, std::vector<uint8_t> & data, TextureHandle textureHandle, TextureFormat format, size_t size)
{
  if (tile->data && tile->data->generation < requestGeneration) {
    releaseTileData(*tile->data);
 
    if (!tile->isInvalidated()) {
      auto & id = tile->identifier;
 
      LOG_DEBUG(logger, "Releasing overwritten tile [%d, %d, %d].", id.level, id.x, id.y);
    }
  }
 
  tile->data = tile->data ? tile->data : &residentTiles[tile->identifier.getHashCode()];
 
  if (tile->data->generation >= requestGeneration) {
    // While processing this response, newer data has already been loaded. Discard
    // any texture data and buffer data that will not be used.
    deallocateTileStorage(data);
    if (HandleIsValid(textureHandle) && textureHandle != invalidTileHandle) {
      releaseTexture(textureHandle, size);
    }
    return;
  }
 
  tile->data->textureHandle = textureHandle;
  tile->data->data = std::move(data);
  tile->data->format = format;
  tile->data->size = size;
  tile->data->generation.store(tile->generation);
 
  tile->setValid();
 
  updateTileUsage(tile);
 
  return;
}
 
void Cogs::RasterSource::invalidateTile(const RasterTileIdentifier & id, InvalidationFlags::EInvalidationFlags flags)
{
  auto tile = getTile(id);
 
  if (!tile) {
    LOG_WARNING(logger, "Unable to invalidate tile with invalid identifier.");
 
    return;
  }
 
  tile->invalidate();
  tile->unsetRequested();
 
  if (flags & InvalidationFlags::InvalidateParents) {
    auto level = id.level;
 
    while (level-- > 0) {
      auto parentId = RasterTileIdentifier{ level, id.x / 2, id.y / 2 };
 
      auto parentTile = getTile(parentId);
 
      if (!parentTile) {
        LOG_WARNING(logger, "Unable to invalidate missing parent tile.");
        continue;
      }
 
      parentTile->invalidate();
      parentTile->unsetRequested();
    }
  }
}
 
Cogs::RasterTileData * Cogs::RasterSource::getTileData(RasterTile * tile)
{
  return tile->data;
}
 
void Cogs::RasterSource::cancelActiveRequests()
{
  ++generation;
}
 
void Cogs::RasterSource::purgeCache()
{
  assert(!hasProcessingRequests() && "Cannot purge cache with requests still in processing.");
 
  purgeResidentCache();
 
  // Clear LRU queue.
  lruList.clear();
  lruMap.clear();
 
  activeTiles.clear();
}
 
void Cogs::RasterSource::purgeResidentCache()
{
  // For each resident tile
  // Release texture resource from GPU.
  // Release memory buffer.
 
  for (auto & tile : residentTiles) {
    auto & tileData = tile.second;
 
    releaseTileData(tileData);
  }
 
  residentTiles.clear();
}
 
Cogs::TextureHandle Cogs::RasterSource::loadTexture(const unsigned char * data, const int width, const int height, const TextureFormat format, const size_t size)
{
  textureBufferSize += size;
  return device->getTextures()->loadTexture(data, width, height, format);
}
 
void Cogs::RasterSource::releaseTexture(TextureHandle texture, const size_t size)
{
  device->getTextures()->releaseTexture(texture);
  textureBufferSize -= size;
}
 
void Cogs::RasterSource::releaseTileData(RasterTileData & tileData)
{
  if (HandleIsValid(tileData.textureHandle) && tileData.textureHandle != invalidTileHandle) {
    releaseTexture(tileData.textureHandle, tileData.size);
  }
 
  if (tileData.data.size()) {
    deallocateTileStorage(tileData.data);
  }
}
 
void Cogs::RasterSource::purgeOldData()
{
  for (auto & tileData : oldTileData) {
    releaseTileData(tileData);
  }
 
  oldTileData.clear();
}