ClipmapUpdater.cpp

#include "ClipmapUpdater.h"
 
#include "ClipmapLevel.h"
#include "ClipmapUpdate.h"
#include "ClipmapTerrainTypes.h"
#include "Effects.h"
#include "Extent.h"
#include "NormalUpdater.h"
#include "RenderContext.h"
#include "Raster/RasterSource.h"
#include "Raster/RasterSourceSubscription.h"
 
#include "Rendering/IRenderTargets.h"
#include "Rendering/IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ClipmapUpdater");
}
 
namespace Cogs
{
  struct LevelTextureParameters
  {
    Matrix projectionMatrix;
    Vector2 oneOverTextureSize;
  };
 
  struct RegionParameters
  {
    Vector2 sourceOrigin;
    Vector2 updateSize;
    Vector2 destinationOffset;
    int clear;
    int pad;
    Vector4 clearValue;
  };
}
 
void Cogs::ClipmapUpdater::initialize(IGraphicsDevice * device, NormalUpdater * normalUpdater)
{
  auto positionFormat = initializeGeometry(device);
  initializeStateObjects(device);
  initializeShaders(device, positionFormat);
  initializeSamplerStates(device);
 
  this->normalUpdater = normalUpdater;
 
  this->upsampler.initialize(device);
}
 
void Cogs::ClipmapUpdater::applyNewTiles(RenderContext & context,
                                         ClipmapLevel * level,
                                         const RasterTile ** tiles,
                                         const size_t numTiles,
                                         std::vector<const RasterTile *> & updatedTiles,
                                         std::vector<ClipmapLevel *> & updatedLevels,
                                         std::vector<ClipmapUpdate> & normalUpdates)
{
  const Extent & nextExtent = level->nextExtent;
 
  const auto & rasterExtent = level->rasterLevel->getIndexExtent();
 
  ClipmapUpdate rasterUpdate(level, rasterExtent);
  ClipmapUpdate entireLevel(level, nextExtent);
 
  entireLevel = ClipmapUpdate::intersectUpdates(rasterUpdate, entireLevel);
 
  static std::vector<ClipmapUpdate> intersections;
  intersections.clear();
 
  for (size_t i = 0; i < numTiles; ++i) {
    ClipmapUpdate thisTile(level, tiles[i]->extent);
 
    ClipmapUpdate intersection = ClipmapUpdate::intersectUpdates(entireLevel, thisTile);
 
    if (intersection.getWidth() > 0 && intersection.getHeight() > 0) {
      intersections.push_back(intersection);
 
      if (level->normalLevel) {
        normalUpdates.push_back(intersection);
      }
 
      updatedTiles.push_back(tiles[i]);
      updatedLevels.push_back(level);
    }
  }
 
  if (!intersections.size()) { return; }
 
  updateRasterLevel(context, intersections.data(), intersections.size());
}
 
size_t Cogs::ClipmapUpdater::updateRasterLevel(RenderContext & renderContext, ClipmapUpdate * clipmapUpdates, const size_t numUpdates)
{
  static std::vector<ClipmapUpdate> updates;
  static std::vector<ClipmapUpdate> clearUpdates;
  static std::vector<RasterTileRegion> clearTileRegions;
  static std::vector<RasterTileRegion> tileRegions;
 
  static std::vector<const RasterTileRegion * > residentTileRegions;
  static std::vector<TextureHandle> residentTileTextures;
  static std::vector<const RasterTileRegion * > missingTileRegions;
 
  static std::vector<RasterTile * > needsUpsample;
  static std::vector<RasterTileRegion * > needsUpsampleRegion;
 
  RasterTile clearTile{};
 
  clearTileRegions.clear();
  tileRegions.clear();
 
  residentTileRegions.clear();
  residentTileTextures.clear();
  missingTileRegions.clear();
 
  needsUpsample.clear();
  needsUpsampleRegion.clear();
 
  for (size_t i = 0; i < numUpdates; ++i) {
    updates.clear();
    clearUpdates.clear();
 
    auto & currentUpdate = clipmapUpdates[i];
    auto rasterLevel = currentUpdate.getLevel()->rasterLevel;
 
    ClipmapUpdate rasterUpdate(currentUpdate.getLevel(), rasterLevel->getIndexExtent());
 
    auto intersected = ClipmapUpdate::intersectUpdates(rasterUpdate, currentUpdate);
 
    if (intersected.getWidth() < currentUpdate.getWidth() || intersected.getHeight() < currentUpdate.getHeight()) {
      // We need to fill in invalid data.
      ClipmapUpdate::splitUpdateToAvoidWrapping(currentUpdate, clearUpdates);
 
      for (auto & clearUpdate : clearUpdates) {
        clearTileRegions.push_back(RasterTileRegion{ &clearTile, clearUpdate.getExtent() });
      }
    }
 
    ClipmapUpdate::splitUpdateToAvoidWrapping(intersected, updates);
 
    for (auto & update : updates) {
      Extent extent = {
        update.getWest(),
        update.getSouth(),
        update.getEast(),
        update.getNorth()
      };
 
      clipmapUpdates[i].getLevel()->rasterLevel->getTilesInExtent(extent, tileRegions);
    }
  }
 
  for (auto & clearRegion : clearTileRegions) {
    residentTileRegions.push_back(&clearRegion);
    residentTileTextures.push_back(TextureHandle::NoHandle);
  }
 
  auto source = clipmapUpdates[0].getLevel()->rasterLevel->getSource();
 
  {
    ReadLock lock(*source);
 
    for (auto & region : tileRegions) {
      TextureHandle tileTexture = TextureHandle::InvalidHandle;
 
      const bool hasResidentTile = source->tryGetTextureHandle(region.tile, tileTexture);
 
      if (hasResidentTile) {
        if (tileTexture == TextureHandle::NoHandle) {
          needsUpsample.push_back(region.tile);
          needsUpsampleRegion.push_back(&region);
        } else {
          residentTileRegions.push_back(&region);
          residentTileTextures.push_back(tileTexture);
        }
      } else {
        missingTileRegions.push_back(&region);
      }
    }
  }
 
  for (size_t i = 0; i < needsUpsample.size(); ++i) {
    const auto tileId = needsUpsample[i]->identifier;
 
    if (tileId.level == 0) continue;
 
    const RasterTileIdentifier parentId = { tileId.level - 1, tileId.x / 2, tileId.y / 2 };
 
    WriteLock lock(*source);
 
    auto parentTile = source->getTile(parentId);
    auto newTextureHandle = upsampler.upsampleTile(renderContext, source, parentTile, needsUpsample[i]);
 
    if (newTextureHandle != TextureHandle::NoHandle) {
      residentTileRegions.push_back(needsUpsampleRegion[i]);
      residentTileTextures.push_back(newTextureHandle);
    }
  }
 
  renderTilesToLevelTexture(renderContext, clipmapUpdates[0].getLevel(), (const RasterTileRegion **)residentTileRegions.data(), residentTileTextures.data(), residentTileRegions.size());
 
  upsampler.upsampleLevelRegions(renderContext, clipmapUpdates[0].getLevel(), missingTileRegions.data(), missingTileRegions.size());
 
  return missingTileRegions.size();
}
 
void Cogs::ClipmapUpdater::renderTilesToLevelTexture(RenderContext & renderContext,
                                                     ClipmapLevel * level,
                                                     const RasterTileRegion ** regions,
                                                     const TextureHandle * tileTextures,
                                                     const size_t numRegions)
{
  if (!numRegions) return;
 
  IContext * context = renderContext.context;
 
  const RenderTexture * levelTexture = &level->renderTexture;
  const TextureOrigin originInTextures = level->origin;
  const Extent & nextExtent = level->nextExtent;
 
  const float w = static_cast<float>(levelTexture->width);
  const float h = static_cast<float>(levelTexture->height);
 
  context->setEffect(updateEffectHandle);
 
  context->setRenderTarget(levelTexture->renderTarget, DepthStencilHandle::InvalidHandle);
  context->setViewport(0, 0, w, h);
 
  const uint32_t strides[] = { 2 * sizeof(float) };
  context->setVertexBuffers(&vertexBufferHandle, 1, strides, nullptr);
  context->setInputLayout(updateLayoutHandle);
 
  context->setConstantBuffer(levelBufferBinding, levelBufferHandle);
  context->setConstantBuffer(regionBufferBinding, regionBufferHandle);
 
  glm::mat4 projection;
 
  if (level->background) {
    projection = glm::ortho<float>(0, static_cast<float>(nextExtent.getWidth()), 0, static_cast<float>(nextExtent.getHeight()), -1.0f, 1.0f);
  } else {
    projection = glm::ortho<float>(0, w, 0, h, -1.0f, 1.0f);
  }
 
  {
    MappedBuffer<LevelTextureParameters> levelParameters(context, levelBufferHandle, MapMode::WriteDiscard);
 
    if (levelParameters) {
      levelParameters->projectionMatrix = projection;
      levelParameters->oneOverTextureSize[0] = 1.0f / (float)level->rasterLevel->getSource()->getTileWidth();
      levelParameters->oneOverTextureSize[1] = 1.0f / (float)level->rasterLevel->getSource()->getTileHeight();
    }
  }
 
  TextureHandle currentTextureHandle = TextureHandle::NoHandle;
 
  for (size_t i = 0; i < numRegions; ++i) {
    if (tileTextures[i] != currentTextureHandle) {
      context->setTexture(textureBinding, tileTextures[i]);
      context->setSamplerState(samplerStateBinding, nearestClampStateHandle);
      currentTextureHandle = tileTextures[i];
    }
 
    const RasterTileRegion * region = regions[i];
 
    const int clipmapWidth = nextExtent.getWidth();
    const int clipmapHeight = nextExtent.getHeight();
 
    const int destWest = (originInTextures.x + (region->tile->extent.west + region->extent.west - nextExtent.west)) % clipmapWidth;
    const int destSouth = (originInTextures.y + (region->tile->extent.south + region->extent.south - nextExtent.south)) % clipmapHeight;
 
    const int width = region->extent.getWidth();
    const int height = region->extent.getHeight();
 
    {
      MappedBuffer<RegionParameters> regionParameters(context, regionBufferHandle, MapMode::WriteDiscard);
 
      if (regionParameters) {
        regionParameters->sourceOrigin = Vector2(static_cast<float>(region->extent.west), static_cast<float>(region->extent.south));
        regionParameters->updateSize = Vector2(static_cast<float>(width), static_cast<float>(height));
        regionParameters->destinationOffset = Vector2(static_cast<float>(destWest), static_cast<float>(destSouth));
        regionParameters->clear = currentTextureHandle == TextureHandle::NoHandle;
        if (regionParameters->clear) {
          const float noData = level->rasterLevel->getNoData();
          regionParameters->clearValue = glm::vec4(std::isnan(noData) ? 0.0f : noData);
        }
      }
    }
 
    context->draw(PrimitiveType::TriangleList, 0, 6);
  }
}
 
void Cogs::ClipmapUpdater::applyIfNotLoaded(RenderContext & renderContext, const WorldOptions & worldOptions, ClipmapLevel * level, const RasterTileIdentifier & tileId, const size_t maxLevel)
{
  auto source = level->rasterLevel->getSource();
 
  RasterTile * tile;
  {
    ReadLock lock(*source);
 
    tile = source->getTile(tileId);
 
    if (!tile || tile->isResident()) return;
  }
 
  std::vector<const RasterTile *> updatedTiles;
  std::vector<ClipmapLevel *> updatedLevels;
  std::vector<ClipmapUpdate> normalUpdates;
 
  applyNewTiles(renderContext, level, (const RasterTile **)&tile, 1, updatedTiles, updatedLevels, normalUpdates);
 
  for (auto & normalUpdate : normalUpdates) {
    normalUpdater->updateNormalLevel(renderContext, worldOptions, normalUpdate, *normalUpdate.getLevel()->normalLevel);
  }
 
  for (size_t i = 0; i < updatedTiles.size(); ++i) {
    auto finerLevel = updatedLevels[i]->finerLevel;
 
    if (finerLevel && finerLevel->index <= maxLevel) {
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getSouthwestChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getSoutheastChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getNorthwestChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getNortheastChild(), maxLevel);
    }
  }
}
 
void Cogs::ClipmapUpdater::preloadTiles(ClipmapLevel & clipmapLevel, const Extent & extent)
{
  // Preload the entire world at level 0
  std::vector<RasterTileRegion> regions;
  clipmapLevel.rasterLevel->getTilesInExtent(extent, regions);
 
  auto source = clipmapLevel.rasterLevel->getSource();
 
  WriteLock lock(*source);
 
  for (auto & region : regions) {
    if (!region.tile->isRequested()) {
      requestTileLoad(source, clipmapLevel, region.tile);
      source->refTile(region.tile);
    }
  }
}
 
void Cogs::ClipmapUpdater::requestTileLoad(RasterSource * rasterSource, ClipmapLevel & /*level*/, RasterTile * tile)
{
  TileLoadRequest request = { tile };
 
  tile->setRequested();
 
  rasterSource->requestTile(request);
}
 
size_t Cogs::ClipmapUpdater::applyNewData(RenderContext & renderContext, const WorldOptions & worldOptions, RasterSourceSubscription & subscription, std::vector<ClipmapLevel> & clipmapLevels, const size_t maxLevel)
{
  std::vector<TileLoadResponse> responses;
  const auto maxTiles = renderContext.maxAppliedTilesPerFrame;
 
  subscription.getResponses(responses, maxTiles);
 
  if (!responses.size()) return 0;
 
  std::sort(responses.begin(), responses.end(),
    [](const TileLoadResponse & a, const TileLoadResponse & b)
  {
    return a.rasterLevel < b.rasterLevel;
  });
 
  std::vector<const RasterTile *> tiles;
  tiles.reserve(128);
 
  std::vector<const RasterTile *> updatedTiles;
  std::vector<ClipmapLevel *> updatedLevels;
  std::vector<ClipmapUpdate> normalUpdates;
 
  auto currentLevel = responses.back().rasterLevel;
 
  for (auto & response : responses) {
    const RasterTile * tile = response.tile;
 
    if (response.rasterLevel != currentLevel) {
      for (auto & c : clipmapLevels) {
        if (c.index <= maxLevel && c.rasterLevel->getLevel() == currentLevel) {
          applyNewTiles(renderContext, &c, tiles.data(), tiles.size(), updatedTiles, updatedLevels, normalUpdates);
        }
      }
 
      currentLevel = response.rasterLevel;
      tiles.clear();
    }
 
    tiles.push_back(tile);
  }
 
  if (tiles.size()) {
    for (auto & c : clipmapLevels) {
      if (c.index <= maxLevel && c.rasterLevel->getLevel() == tiles[0]->identifier.level) {
        applyNewTiles(renderContext, &c, tiles.data(), tiles.size(), updatedTiles, updatedLevels, normalUpdates);
      }
    }
  }
 
  for (auto & normalUpdate : normalUpdates) {
    normalUpdater->updateNormalLevel(renderContext, worldOptions, normalUpdate, *normalUpdate.getLevel()->normalLevel);
  }
 
  for (size_t i = 0; i < updatedTiles.size(); ++i) {
    const auto tile = updatedTiles[i];
    auto finerLevel = updatedLevels[i]->finerLevel;
 
    if (finerLevel && finerLevel->index <= maxLevel) {
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getSouthwestChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getSoutheastChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getNorthwestChild(), maxLevel);
      applyIfNotLoaded(renderContext, worldOptions, finerLevel, tile->identifier.getNortheastChild(), maxLevel);
    }
  }
 
  return responses.size();
}
 
void Cogs::ClipmapUpdater::requestTileResidency(ClipmapLevel & level)
{
  static std::vector<RasterTileRegion> tileRegions;
  tileRegions.clear();
 
  const Extent & nextExtent = level.nextExtent;
 
  level.rasterLevel->getTilesInExtent(nextExtent, tileRegions);
 
  auto source = level.rasterLevel->getSource();
 
  level.isHeight = source->isHeight;
 
  for (auto & region : tileRegions) {
    auto tile = region.tile;
 
    WriteLock lock(*source);
 
    if (!tile->isResident() && !tile->isRequested()) {
      requestTileLoad(source, level, tile);
    } else if (level.isHeight && tile->data) {
      level.minZ = std::min(level.minZ, tile->data->minZ);
      level.maxZ = std::max(level.maxZ, tile->data->maxZ);
    }
  }
 
  if (level.isHeight && level.minZ == 0 && level.maxZ == 0) {
    level.minZ = source->minZ;
    level.maxZ = source->maxZ;
  }
}
 
void Cogs::ClipmapUpdater::initializeStateObjects(IGraphicsDevice * device)
{
  IRenderTargets * renderTargets = device->getRenderTargets();
 
  RasterizerState rasterizerState = { false, RasterizerState::CullMode::Front, false, true, 0.0f, 0.0f, 0.0f, false, false };
  rasterizerStateHandle = renderTargets->loadRasterizerState(rasterizerState);
 
  DepthStencilState depthStencilState = {
    false,
    false,
    DepthStencilState::Always
  };
 
  depthStencilStateHandle = renderTargets->loadDepthStencilState(depthStencilState);
}
 
void Cogs::ClipmapUpdater::initializeShaders(IGraphicsDevice * device, VertexFormatHandle positionFormat)
{
  auto effects = device->getEffects();
  auto buffers = device->getBuffers();
 
  LOG_DEBUG(logger, "Loading clipmap update effect.");
 
  updateEffectHandle = Terrain::EffectLoader::loadEffect(effects, "ClipmapUpdateVS", "ClipmapUpdatePS");
 
  if (!HandleIsValid(updateEffectHandle)) {
    LOG_ERROR(logger, "Error loading clipmap update effect.");
 
    return;
  }
 
  updateLayoutHandle = buffers->loadInputLayout(&positionFormat, 1, updateEffectHandle);
 
  levelBufferHandle = buffers->loadBuffer(nullptr, sizeof(LevelTextureParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  levelBufferBinding = effects->getConstantBufferBinding(updateEffectHandle, "LevelTextureParameters");
 
  regionBufferHandle = buffers->loadBuffer(nullptr, sizeof(RegionParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  regionBufferBinding = effects->getConstantBufferBinding(updateEffectHandle, "RegionParameters");
 
  textureBinding = effects->getTextureBinding(updateEffectHandle, "imagery", 0);
  samplerStateBinding = effects->getSamplerStateBinding(updateEffectHandle, "imagerySampler", 0);
}
 
void Cogs::ClipmapUpdater::initializeSamplerStates(IGraphicsDevice * device)
{
  SamplerState nearestClampState = {
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::FilterMode::MinMagMipPoint,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  nearestClampStateHandle = device->getTextures()->loadSamplerState(nearestClampState);
}
 
Cogs::VertexFormatHandle Cogs::ClipmapUpdater::initializeGeometry(IGraphicsDevice * device)
{
  VertexElement positionElement = { 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 };
  VertexFormatHandle positionFormat = device->getBuffers()->createVertexFormat(&positionElement, 1);
  vertexBufferHandle = device->getBuffers()->loadVertexBuffer(quadVertices, 6, positionFormat);
  return positionFormat;
}
 
void Cogs::ClipmapUpdater::setupRenderingState(RenderContext & renderContext)
{
  renderContext.context->setDepthStencilState(depthStencilStateHandle);
  renderContext.context->setRasterizerState(rasterizerStateHandle);
}