ClipmapManager.cpp

#include "ClipmapManager.h"
 
#include "ClipmapUpdate.h"
#include "ClipmapParameterCalculation.h"
#include "ClipmapDebug.h"
#include "Effects.h"
#include "ExtentCalculation.h"
#include "Raster/RasterSource.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/CommandGroupAnnotation.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cmath>
#include <thread>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ClipmapManager");
 
  const bool enableMipMapping = false;
}
 
Cogs::ClipmapManager::ClipmapManager()
{
  std::memset(&metrics, 0, sizeof(TerrainMetrics));
}
 
Cogs::ClipmapManager::~ClipmapManager()
{
  detachResponseHandlers();
 
  clipmapRenderer.cleanup(device);
}
 
void Cogs::ClipmapManager::setRasterSources(const RasterSourcePtr & terrain, const std::vector<RasterSourcePtr> & imagery)
{
  LOG_DEBUG(logger, "Setting raster sources...");
 
  detachResponseHandlers();
 
  terrainSource.setup(terrain);
 
  imagerySources.resize(imagery.size());
  imageryEnabled.resize(imagerySources.size(), true);
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    imagerySources[i].setup(imagery[i]);
  }
 
  sourcesNeedUpdate = true;
  effectsNeedUpdate = true;
}
 
void Cogs::ClipmapManager::setClipmapParameters(const ClipmapParameters * parameters)
{
  LOG_DEBUG(logger, "Setting clipmap parameters...");
 
  // We need to rebuild effects for different normal computation policies.
  effectsNeedUpdate |= parameters->precomputeNormals != this->parameters.precomputeNormals;
 
  this->parameters = *parameters;
 
  sourcesNeedUpdate = true;
  geometryNeedsUpdate = true;
}
 
void Cogs::ClipmapManager::setCustomParameters(const unsigned char * data, int count)
{
  clipmapRenderer.setCustomParameters(data, count);
}
 
void Cogs::ClipmapManager::initialize(IGraphicsDevice * device)
{
  this->device = device;
 
  Terrain::EffectLoader::setExtension(".hlsl"); // Seems to only have .hlsl shaders now
 
  //First time we render depth for this camera, setup the state for it:
  clipmapRenderer.raypickDepthData.emplace_back();
  clipmapRenderer.raypickDepthData.back().initialize(device, 512, 512);
 
  // Init subsystems
  clipmapRenderer.initializeTextures(device->getTextures());
  clipmapRenderer.initializeRasterizerStates(device->getRenderTargets());
  clipmapRenderer.initializeRenderTargets(device->getRenderTargets());
 
  oceanRenderer.initialize(&clipmapRenderer, device);
  oceanRenderer.initializeTextures(device->getTextures(), device->getRenderTargets());
 
  depthQuery.initialize(device, &clipmapRenderer);
 
  updater.initialize(device, &normalUpdater);
  normalUpdater.initialize(device);
 
  initialized = true;
}
 
void Cogs::ClipmapManager::initializeGeometry()
{
  const size_t clipmapPosts = this->parameters.clipmapPosts;
  const size_t clipmapSegments = clipmapPosts - 1;
  const size_t fillPatchPosts = (clipmapPosts + 1) / 4; // M
  const size_t fillPatchSegments = fillPatchPosts - 1;
 
  if (clipmapGeometry.initialized) {
    LOG_DEBUG(logger, "Releasing geometry...");
 
    Cogs::releaseGeometry(clipmapGeometry, device->getBuffers());
  }
 
  LOG_DEBUG(logger, "Initializing geometry...");
 
  Cogs::initializeGeometry(clipmapGeometry, device->getBuffers(), fillPatchPosts, fillPatchSegments, clipmapSegments, clipmapPosts);
 
  clipmapState.fillPatchPosts = fillPatchPosts;
  clipmapState.fillPatchSegments = fillPatchSegments;
 
  clipmapState.clipmapPosts = clipmapPosts;
  clipmapState.clipmapSegments = clipmapSegments;
 
  clipmapState.oneOverBlendedRegionSize = (float)(10.0 / clipmapPosts);
  clipmapState.unblendedRegionSize = (float)(clipmapSegments / 2 - clipmapPosts / 10.0 - 1);
}
 
void Cogs::ClipmapManager::initializeLevels()
{
  CommandGroupAnnotation preGroup(device->getImmediateContext(), "Terrain::initializeLevels");
 
  const size_t numTerrainLevels = terrainSource->getLevels().size();
  const size_t numLevels = numTerrainLevels;
 
  cleanupLevels();
 
  if (!numLevels) {
    LOG_ERROR(logger, "No valid terrain levels found in raster source.");
 
    return;
  }
 
  this->imagery.resize(imagerySources.size());
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
 
    this->imagery[i].resize(numLevels);
  }
 
  this->terrainLevels.resize(numLevels);
 
  if (parameters.precomputeNormals) {
    this->normalLevels.resize(numLevels);
  }
 
  const size_t clipmapPosts = this->parameters.clipmapPosts;
 
  for (size_t i = 0; i < numLevels; ++i) {
    ClipmapLevel & terrainLevel = terrainLevels[i];
 
    RasterLevel & terrainRasterLevel = terrainSource->getLevels()[i < numTerrainLevels ? i : numTerrainLevels - 1];
 
    terrainLevel.index = i;
 
    terrainLevel.rasterLevel = &terrainRasterLevel;
    terrainLevel.renderTexture = createTexture(clipmapPosts, clipmapPosts, TextureFormat::R32_FLOAT);
    terrainLevel.coarserLevel = i == 0 ? &terrainLevel : &terrainLevels[i - 1];
    terrainLevel.finerLevel = i == (numLevels - 1) ? nullptr : &terrainLevels[i + 1];
 
    if (parameters.precomputeNormals) {
      ClipmapLevel & normalLevel = normalLevels[i];
 
      normalLevel.renderTexture = createTexture(clipmapPosts, clipmapPosts, TextureFormat::R16G16B16A16_FLOAT);
      normalLevel.coarserLevel = i == 0 ? &normalLevel : &normalLevels[i - 1];
      normalLevel.finerLevel = i == (numLevels - 1) ? nullptr : &normalLevels[i + 1];
 
      terrainLevel.normalLevel = &normalLevel;
    }
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      std::vector<ClipmapLevel> & imageryLevels = imagery[j];
 
      ClipmapLevel & imageryLevel = imageryLevels[i];
 
      imageryLevel.index = i;
 
      imageryLevel.coarserLevel = i == 0 ? &imageryLevel : &imageryLevels[i - 1];
      imageryLevel.finerLevel = i == (numLevels - 1) ? nullptr : &imageryLevels[i + 1];
 
      // Find the first imagery level that meets our resolution needs.
      double longitudeResRequired = terrainRasterLevel.getPostDeltaLongitude() / parameters.imageryResolutionFactor[j];
      double latitudeResRequired = terrainRasterLevel.getPostDeltaLatitude() / parameters.imageryResolutionFactor[j];
 
      RasterLevel * imageryRasterLevel = nullptr;
 
      auto & levels = imagerySources[j]->getLevels();
 
      for (size_t k = 0; k < levels.size(); ++k) {
        imageryRasterLevel = &levels[k];
 
        if (imageryRasterLevel->getPostDeltaLongitude() <= longitudeResRequired && imageryRasterLevel->getPostDeltaLatitude() <= latitudeResRequired) {
          if (k < levels.size() - parameters.imageryIndexOffset[j] && i > 0) {
            imageryRasterLevel = &levels[k + parameters.imageryIndexOffset[j]];
          }
          break;
        }
      }
 
      const int imageryWidth = (int)std::ceil(clipmapPosts * terrainRasterLevel.getPostDeltaLongitude() / imageryRasterLevel->getPostDeltaLongitude());
      const int imageryHeight = (int)std::ceil(clipmapPosts * terrainRasterLevel.getPostDeltaLatitude() / imageryRasterLevel->getPostDeltaLatitude());
 
      imageryLevel.rasterLevel = imageryRasterLevel;
      imageryLevel.renderTexture = createTexture(imageryWidth, imageryHeight, imagerySources[j]->format, enableMipMapping);
    }
  }
 
  initializeBackgroundLevels();
}
 
void Cogs::ClipmapManager::initializeBackgroundLevels()
{
  auto findSize = [](const int posts) -> int {
    if (posts <= 2048) return posts / 2;
    if (posts <= 4096) return posts / 2;
    else return 2048;
  };
 
  RasterLevel & terrainRasterLevel = terrainSource->getLevels()[0];
 
  backgroundLevel = ClipmapLevel();
 
  backgroundLevel.index = 0;
  backgroundLevel.background = true;
  backgroundLevel.rasterLevel = &terrainRasterLevel;
 
  glm::vec4 clearColor{ 0 };
  const auto noData = terrainRasterLevel.getNoData();
  if (!std::isnan(noData)) {
    clearColor = glm::vec4{ noData };
  }
 
  backgroundLevel.renderTexture = createTexture(findSize(terrainRasterLevel.getLongitudePosts()), findSize(terrainRasterLevel.getLatitudePosts()), TextureFormat::R32_FLOAT, false, clearColor);
  backgroundLevel.coarserLevel = &backgroundLevel;
  backgroundLevel.finerLevel = &terrainLevels[0];
  terrainLevels[0].coarserLevel = &backgroundLevel;
 
  if (parameters.precomputeNormals) {
    backgroundNormalLevel = ClipmapLevel();
 
    backgroundNormalLevel.index = 0;
    backgroundNormalLevel.background = true;
    backgroundNormalLevel.renderTexture = createTexture(backgroundLevel.renderTexture.width, backgroundLevel.renderTexture.height, TextureFormat::R16G16B16A16_FLOAT);
    backgroundNormalLevel.coarserLevel = &backgroundNormalLevel;
    backgroundNormalLevel.finerLevel = &normalLevels[0];
 
    backgroundLevel.normalLevel = &backgroundNormalLevel;
  }
 
  backgroundImagery.clear();
  backgroundImagery.resize(imagery.size());
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    std::vector<ClipmapLevel> & imageryLevels = imagery[i];
 
    backgroundImagery[i].index = 0;
    backgroundImagery[i].background = true;
 
    backgroundImagery[i].coarserLevel = &backgroundImagery[i];
    backgroundImagery[i].finerLevel = &imageryLevels[0];
    imageryLevels[0].coarserLevel = &backgroundImagery[i];
 
    const ClipmapLevel & imageryLevelZero = imagery[i][0];
    const auto rasterLevel = imageryLevelZero.rasterLevel;
 
    const int imageryWidth = findSize(rasterLevel->getLongitudePosts());
    const int imageryHeight = findSize(rasterLevel->getLatitudePosts());
 
    backgroundImagery[i].rasterLevel = imageryLevelZero.rasterLevel;
    backgroundImagery[i].renderTexture = createTexture(imageryWidth * 2, imageryHeight * 2, imageryLevelZero.rasterLevel->getSource()->format, enableMipMapping);
  }
}
 
void Cogs::ClipmapManager::cleanupLevels()
{
  auto clearLevels = [&](std::vector<ClipmapLevel> & levels) {
    for (auto & level : levels) {
      destroyTexture(level.renderTexture);
    }
 
    levels.clear();
  };
 
  for (auto & imageryLayer : imagery) {
    clearLevels(imageryLayer);
  }
 
  clearLevels(terrainLevels);
  clearLevels(normalLevels);
 
  // Background needs update on first render.
  backgroundNeedsUpdate = true;
 
  if (HandleIsValid(backgroundLevel.renderTexture.handle)) {
    destroyTexture(backgroundLevel.renderTexture);
 
    if (HandleIsValid(backgroundNormalLevel.renderTexture.handle)) {
      destroyTexture(backgroundNormalLevel.renderTexture);
    }
 
    for (auto & backgroundImageryLayer : backgroundImagery) {
      destroyTexture(backgroundImageryLayer.renderTexture);
    }
  }
}
 
void Cogs::ClipmapManager::detachResponseHandlers()
{
  if (!terrainSource.isReady()) return;
 
  terrainSource.teardown();
 
  for (auto & imagerySource : imagerySources) {
    imagerySource.teardown();
  }
}
 
void Cogs::ClipmapManager::update()
{
  CommandGroupAnnotation preGroup(device->getImmediateContext(), "Terrain::update");
 
  needsUpdate = false;
 
  if (geometryNeedsUpdate) {
    initializeGeometry();
 
    geometryNeedsUpdate = false;
  }
 
  if (sourcesNeedUpdate && terrainSource.isReady()) {
    updateSharedDevice(device);
 
    initializeLevels();
 
    preloadLevelZeroTiles();
 
    sourcesNeedUpdate = false;
  }
 
  if (oceanActive) {
    oceanRenderer.update();
  }
}
 
size_t Cogs::ClipmapManager::preRender(RenderContext & renderContext)
{
  if (renderContext.oceanEnabled) {
    oceanActive = true;
  }
 
  CommandGroupAnnotation preGroup(renderContext.context, "Terrain::preRender");
 
  if (!terrainLevels.size()) {
    LOG_ERROR(logger, "No terrain levels set. Pre render not possible.");
 
    return 0;
  }
 
  if (!updateOptions.enableUpdate) {
    renderContext.cullVolume.frustum = previousContext.cullVolume.frustum;
    renderContext.cullOrigin = previousContext.cullOrigin;
  }
 
  updater.setupRenderingState(renderContext);
 
  const size_t maxLevel = calculateCenterAndMaxLevel(renderContext);
 
  ClipmapLevel & firstLevel = terrainLevels[terrainLevels.size() - 1];
 
  calculateNextExtent(clipmapState.clipmapCenter.x, clipmapState.clipmapCenter.y, clipmapState, firstLevel);
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    ClipmapLevel & firstImagery = imagery[i][terrainLevels.size() - 1];
 
    if (imageryEnabled[i]) {
      updateImageryExtent(firstImagery, firstLevel);
    }
  }
 
  updateOriginInTextures(firstLevel);
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    if (imageryEnabled[i]) {
      updateOriginInTextures(imagery[i][terrainLevels.size() - 1]);
    }
  }
 
  for (int i = static_cast<int>(terrainLevels.size() - 2); i >= 0; --i) {
    ClipmapLevel & terrainLevel = terrainLevels[i];
 
    calculateLevelNextExtent(terrainLevel, *terrainLevel.finerLevel, clipmapState);
    updateOriginInTextures(terrainLevel);
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      ClipmapLevel & imageryLevel = imagery[j][i];
 
      updateImageryExtent(imageryLevel, terrainLevel);
      updateOriginInTextures(imageryLevel);
    }
  }
 
  if (updater.applyNewData(renderContext, worldOptions, terrainSource, terrainLevels, maxLevel) != 0) {
    touch();
  }
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    if (imageryEnabled[i]) {
      if (updater.applyNewData(renderContext, worldOptions, imagerySources[i], imagery[i], maxLevel) != 0) {
        touch();
      }
    }
  }
 
  requestTileLoads(renderContext, maxLevel);
 
  updateClipmapLevels(renderContext, worldOptions, maxLevel);
 
  updateBackgroundLevel(renderContext, worldOptions);
 
  // Restore the context to its original state
  renderContext.context->setRenderTarget(renderContext.renderTarget, renderContext.depthStencilTarget);
  renderContext.context->setViewport(renderContext.viewportX, renderContext.viewportY, renderContext.width, renderContext.height);
  renderContext.context->setDepthStencilState(DepthStencilStateHandle::NoHandle);
 
  if (oceanActive) {
    oceanRenderer.preRender(renderContext);
  }
 
  // Restore the context to its original state
  renderContext.context->setRenderTarget(renderContext.renderTarget, renderContext.depthStencilTarget);
  renderContext.context->setViewport(renderContext.viewportX, renderContext.viewportY, renderContext.width, renderContext.height);
  renderContext.context->setDepthStencilState(DepthStencilStateHandle::NoHandle);
 
  updateOptions.invalidateNormals = false;
 
  if(renderContext.reverseDepth != clipmapRenderer.reverseDepth){
    if (renderContext.reverseDepth) {
      clipmapRenderer.reverseDepth = true;
      clipmapRenderer.initializeRasterizerStates(device->getRenderTargets());
    }
    else {
      clipmapRenderer.reverseDepth = false;
      clipmapRenderer.initializeRasterizerStates(device->getRenderTargets());
    }
  }
 
  return maxLevel;
}
 
void Cogs::ClipmapManager::renderDepth(RenderContext & renderContext, size_t maxLevel)
{
  if (!updateOptions.enableUpdate) {
    renderContext.cullVolume.frustum = previousContext.cullVolume.frustum;
    renderContext.cullOrigin = previousContext.cullOrigin;
  }
 
  auto & permutationRendererData = clipmapRenderer.getPermutationDependentClipmapRendererData(renderContext.permutation);
  auto & permutationRenderContextData = renderContext.getPermutationDependentRenderContextData(renderContext.permutation);
  if (HandleIsValid(permutationRenderContextData.clipmapEffect) && permutationRenderContextData.clipmapEffect != permutationRendererData.clipmapEffect) {
    permutationRendererData.clipmapEffect = permutationRenderContextData.clipmapEffect;
    permutationRendererData.clipmapDepthEffect = permutationRenderContextData.clipmapDepthEffect;
 
    clipmapRenderer.initializeEffects(device->getBuffers(), device->getEffects(), imagerySources.size(), renderContext.permutation);
 
    effectsNeedUpdate = false;
  }
 
  if (!terrainLevels.size()) {
    LOG_ERROR(logger, "No terrain levels set. Render not possible.");
 
    return;
  }
 
  if (renderContext.renderPass == TerrainRenderPass::Reflection) maxLevel = maxLevel > 2 ? maxLevel - 2 : maxLevel;
 
  if (renderOptions.enableMipMapping) {
    updateMipmaps(maxLevel, renderContext.device);
  }
 
  GlobalParameters globalParameters;
 
  calculateGlobalParameters(terrainLevels[0], renderContext, worldOptions, clipmapState, globalParameters);
 
  std::vector<LevelParameters> parameters(maxLevel + 1);
  std::vector<ImageryParameters> imageryParameters(maxLevel + 1);
  LevelParameters backgroundParameters;
  ImageryParameters backgroundImageryParameters;
 
  // Camera center in map coordinates.
  auto & worldScale = worldOptions.worldScale;
  Vector3d scaledCenter = Vector3d(renderContext.center[0] * (1.0 / worldScale[0]), renderContext.center[1] * (1.0 / worldScale[1]), renderContext.center[2]);
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    ClipmapLevel & terrainLevel = terrainLevels[i];
 
    parameters[i].levelIndex = i;
 
    std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      imageryLevels[j] = &imagery[j][i];
    }
 
    calculateLevelParameters(
      terrainLevel,
      imageryLevels,
      parameters[i],
      imageryParameters[i],
      scaledCenter,
      worldOptions.enableNoData);
 
    parameters[i].useBlendRegions = renderOptions.enableBlending;
    parameters[i].viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, terrainLevel);
    parameters[i].useClipping = 0;
  }
 
  std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
  for (size_t j = 0; j < imagerySources.size(); ++j) {
    imageryLevels[j] = &backgroundImagery[j];
  }
 
  calculateLevelParameters(
    backgroundLevel,
    imageryLevels,
    backgroundParameters,
    backgroundImageryParameters,
    scaledCenter,
    worldOptions.enableNoData);
 
  backgroundParameters.useBlendRegions = 0;
  backgroundParameters.viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, backgroundLevel);
  backgroundParameters.useClipping = 1;
  backgroundParameters.levelIndex = 2;
 
  clipmapRenderer.initLevels();
 
  bool rendered = false;
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    rendered = clipmapRenderer.createRenderLevel(
      clipmapGeometry,
      clipmapState,
      terrainLevels[i],
      imagery,
      normalLevels.size() ? &normalLevels[i] : nullptr,
      globalParameters,
      parameters[i],
      imageryParameters[i],
      !rendered);
  }
 
  std::vector<std::vector<ClipmapLevel>> backgroundImageryReferences;
 
  for (size_t i = 0; i < imagery.size(); ++i) {
    std::vector<ClipmapLevel> b;
    b.push_back(backgroundImagery[i]);
    backgroundImageryReferences.push_back(b);
  }
 
  clipmapRenderer.createBackgroundRenderLevel(
    clipmapGeometry,
    clipmapState,
    backgroundLevel,
    backgroundImageryReferences,
    this->parameters.precomputeNormals ? &backgroundNormalLevel : nullptr,
    globalParameters,
    backgroundParameters,
    backgroundImageryParameters);
 
  CommandGroupAnnotation renderGroup(renderContext.context, "Terrain::renderDepth");
 
  // Check if we are rendering the depth pass of a "raypick camera":
  auto pickIndex = renderContext.rayPickIndex;
  if (pickIndex != ClipmapRenderer::NoPickIndex)
  {
    // Check if we have already created the state for rendering this camera
    while(static_cast<int>(clipmapRenderer.raypickDepthData.size()) <= pickIndex) {
      // First time we render depth for this camera, setup the state for it:
      auto& depthData = clipmapRenderer.raypickDepthData.emplace_back();
      depthData.initialize(renderContext.device, renderContext.width, renderContext.height);
    }
 
    {
      CommandGroupAnnotation depthGroup(renderContext.context, "RayPickDepth");
 
      clipmapRenderer.setupDepthPass(renderContext, pickIndex);
      clipmapRenderer.updateGlobalParameters(renderContext, renderOptions, clipmapState, globalParameters);
 
      clipmapRenderer.render(renderContext, renderOptions, worldOptions);
    }
  } else if (!previousContext.offsetEnabled && renderContext.renderPass == TerrainRenderPass::Main) {
    {
      CommandGroupAnnotation depthGroup(renderContext.context, "DepthOnly");
 
      clipmapRenderer.setupDepthPass(renderContext, 0);
      clipmapRenderer.updateGlobalParameters(renderContext, renderOptions, clipmapState, globalParameters);
 
      clipmapRenderer.render(renderContext, renderOptions, worldOptions);
    }
 
    {
      CommandGroupAnnotation depthQueryGroup(renderContext.context, "DepthQuery");
      clipmapRenderer.setupDepthQueryPass(renderContext);
      clipmapRenderer.updateGlobalParameters(renderContext, renderOptions, clipmapState, globalParameters);
 
      clipmapRenderer.render(renderContext, renderOptions, worldOptions);
    }
  }
 
  // Restore original rendering setup.
  auto context = renderContext.context;
  context->setRenderTarget(renderContext.renderTarget, renderContext.depthStencilTarget);
  context->setViewport(renderContext.viewportX, renderContext.viewportY, renderContext.width, renderContext.height);
}
 
void Cogs::ClipmapManager::render(RenderContext & renderContext, size_t maxLevel)
{
  if (!updateOptions.enableUpdate) {
    renderContext.cullVolume.frustum = previousContext.cullVolume.frustum;
    renderContext.cullOrigin = previousContext.cullOrigin;
  }
 
  if (!terrainLevels.size()) {
    LOG_ERROR(logger, "No terrain levels set. Render not possible.");
 
    return;
  }
 
  if (renderContext.renderPass == TerrainRenderPass::Reflection) maxLevel = maxLevel > 2 ? maxLevel - 2 : maxLevel;
 
  if (renderOptions.enableMipMapping) {
    updateMipmaps(maxLevel, renderContext.device);
  }
 
  GlobalParameters globalParameters;
 
  calculateGlobalParameters(terrainLevels[0], renderContext, worldOptions, clipmapState, globalParameters);
 
  std::vector<LevelParameters> parameters(maxLevel + 1);
  std::vector<ImageryParameters> imageryParameters(maxLevel + 1);
  LevelParameters backgroundParameters;
  ImageryParameters backgroundImageryParameters;
 
  // Camera center in map coordinates.
  auto & worldScale = worldOptions.worldScale;
  Vector3d scaledCenter = Vector3d(renderContext.center[0] * (1.0 / worldScale[0]), renderContext.center[1] * (1.0 / worldScale[1]), renderContext.center[2]);
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    ClipmapLevel & terrainLevel = terrainLevels[i];
 
    parameters[i].levelIndex = i;
 
    std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      imageryLevels[j] = &imagery[j][i];
    }
 
    calculateLevelParameters(
      terrainLevel,
      imageryLevels,
      parameters[i],
      imageryParameters[i],
      scaledCenter,
      worldOptions.enableNoData);
 
    parameters[i].useBlendRegions = renderOptions.enableBlending;
    parameters[i].viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, terrainLevel);
    parameters[i].useClipping = 0;
  }
 
  std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
  for (size_t j = 0; j < imagerySources.size(); ++j) {
    imageryLevels[j] = &backgroundImagery[j];
  }
 
  calculateLevelParameters(
    backgroundLevel,
    imageryLevels,
    backgroundParameters,
    backgroundImageryParameters,
    scaledCenter,
    worldOptions.enableNoData);
 
  backgroundParameters.useBlendRegions = 0;
  backgroundParameters.viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, backgroundLevel);
  backgroundParameters.useClipping = 1;
  backgroundParameters.levelIndex = 2;
 
  clipmapRenderer.initLevels();
 
  bool rendered = false;
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    rendered = clipmapRenderer.createRenderLevel(
      clipmapGeometry,
      clipmapState,
      terrainLevels[i],
      imagery,
      normalLevels.size() ? &normalLevels[i] : nullptr,
      globalParameters,
      parameters[i],
      imageryParameters[i],
      !rendered);
  }
 
  std::vector<std::vector<ClipmapLevel>> backgroundImageryReferences;
 
  for (size_t i = 0; i < imagery.size(); ++i) {
    std::vector<ClipmapLevel> b;
    b.push_back(backgroundImagery[i]);
    backgroundImageryReferences.push_back(b);
  }
 
  clipmapRenderer.createBackgroundRenderLevel(
    clipmapGeometry,
    clipmapState,
    backgroundLevel,
    backgroundImageryReferences,
    this->parameters.precomputeNormals ? &backgroundNormalLevel : nullptr,
    globalParameters,
    backgroundParameters,
    backgroundImageryParameters);
 
  {
    CommandGroupAnnotation renderGroup(renderContext.context, "Terrain::render");
    clipmapRenderer.setupRegularPass(renderContext);
    clipmapRenderer.updateGlobalParameters(renderContext, renderOptions, clipmapState, globalParameters);
 
    clipmapRenderer.render(renderContext, renderOptions, worldOptions);
  }
}
 
void Cogs::ClipmapManager::renderOcean(RenderContext & renderContext, size_t maxLevel)
{
  CommandGroupAnnotation renderGroup(renderContext.context, "Terrain::renderOcean");
 
  if (!terrainLevels.size()) {
    LOG_ERROR(logger, "No terrain levels set. Render not possible.");
 
    return;
  }
 
  auto p = renderContext.permutation;
 
  auto & permutationRenderContextData = renderContext.getPermutationDependentRenderContextData(renderContext.permutation);
  auto & permutationOceanData = oceanRenderer.getPermutationDependentOceanRendererData(renderContext.permutation);
  if (oceanActive && HandleIsValid(permutationRenderContextData.oceanEffect) &&
      permutationRenderContextData.oceanEffect != permutationOceanData.oceanEffect) {
    permutationOceanData.oceanEffect = permutationRenderContextData.oceanEffect;
 
    oceanRenderer.initializeEffects(device->getBuffers(), device->getEffects(), imagerySources.size(), p);
  }
 
  if (renderContext.renderPass == TerrainRenderPass::Reflection) maxLevel = maxLevel > 2 ? maxLevel - 2 : maxLevel;
 
  GlobalParameters globalParameters;
 
  calculateGlobalParameters(terrainLevels[0], renderContext, worldOptions, clipmapState, globalParameters);
 
  std::vector<LevelParameters> parameters(maxLevel + 1);
  std::vector<ImageryParameters> imageryParameters(maxLevel + 1);
  LevelParameters backgroundParameters;
  ImageryParameters backgroundImageryParameters;
 
  // Camera center in map coordinates.
  auto & worldScale = worldOptions.worldScale;
  Vector3d scaledCenter = Vector3d(renderContext.center[0] * (1.0 / worldScale[0]), renderContext.center[1] * (1.0 / worldScale[1]), renderContext.center[2]);
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    ClipmapLevel & terrainLevel = terrainLevels[i];
 
    parameters[i].levelIndex = i;
 
    std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      imageryLevels[j] = &imagery[j][i];
    }
 
    calculateLevelParameters(
      terrainLevel,
      imageryLevels,
      parameters[i],
      imageryParameters[i],
      scaledCenter,
      worldOptions.enableNoData);
 
    parameters[i].useBlendRegions = renderOptions.enableBlending;
    parameters[i].viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, terrainLevel);
    parameters[i].useClipping = 0;
  }
 
  std::vector<const ClipmapLevel *> imageryLevels(imagerySources.size());
 
  for (size_t j = 0; j < imagerySources.size(); ++j) {
    imageryLevels[j] = &backgroundImagery[j];
  }
 
  calculateLevelParameters(
    backgroundLevel,
    imageryLevels,
    backgroundParameters,
    backgroundImageryParameters,
    scaledCenter,
    worldOptions.enableNoData);
 
  backgroundParameters.useBlendRegions = 0;
  backgroundParameters.viewPosInClippedLevel = calculateViewPosInClippedLevel(clipmapState, backgroundLevel);
  backgroundParameters.useClipping = 1;
  backgroundParameters.levelIndex = 2;
 
  clipmapRenderer.initLevels();
 
  bool rendered = false;
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    rendered = clipmapRenderer.createRenderLevel(
      clipmapGeometry,
      clipmapState,
      terrainLevels[i],
      imagery,
      normalLevels.size() ? &normalLevels[i] : nullptr,
      globalParameters,
      parameters[i],
      imageryParameters[i],
      !rendered,
      false);
  }
 
  std::vector<std::vector<ClipmapLevel>> backgroundImageryReferences;
 
  for (size_t i = 0; i < imagery.size(); ++i) {
    std::vector<ClipmapLevel> b;
    b.push_back(backgroundImagery[i]);
    backgroundImageryReferences.push_back(b);
  }
 
  clipmapRenderer.createBackgroundRenderLevel(
    clipmapGeometry,
    clipmapState,
    backgroundLevel,
    backgroundImageryReferences,
    this->parameters.precomputeNormals ? &backgroundNormalLevel : nullptr,
    globalParameters,
    backgroundParameters,
    backgroundImageryParameters,
    false);
 
  if (!oceanActive) return;
 
  if (renderContext.renderPass != TerrainRenderPass::Reflection) {
    oceanRenderer.setupOceanPass(renderContext);
    oceanRenderer.updateGlobalParameters(renderContext, renderOptions, clipmapState, globalParameters);
 
    oceanRenderer.render(renderContext, renderOptions, worldOptions, true);
 
    // Maintain continuous rendering when ocean is active.
    touch();
  }
}
 
void Cogs::ClipmapManager::postRender(RenderContext & renderContext)
{
  CommandGroupAnnotation postGroup(renderContext.context, "Terrain::postRender");
 
  if (!terrainLevels.size()) {
    return;
  }
 
  renderDebugOverlays(renderContext);
 
  depthQuery.readBack();
 
  {
    std::lock_guard<RasterSource> terrainLock(*terrainSource.rasterSource);
 
    terrainSource->purgeOldData();
  }
 
  for (auto & imagerySource : imagerySources) {
    std::lock_guard<RasterSource> imageryLock(*imagerySource.rasterSource);
 
    imagerySource->purgeOldData();
  }
 
  size_t index = 0;
  metrics.sourceTextureBuffers[index++] = terrainSource->textureBufferSize;
 
  for (auto & imagerySource : imagerySources) {
    metrics.sourceTextureBuffers[index++] = imagerySource->textureBufferSize;
  }
 
  metrics.numFrames++;
}
 
void Cogs::ClipmapManager::getTerrainMetrics(TerrainMetrics * metrics) const
{
  *metrics = this->metrics;
}
 
void Cogs::ClipmapManager::invalidateRasterSource(RasterSource * rasterSource, bool clearContents)
{
  // Bump the request generation index so in-flight requests get discarded as soon as they are received.
  // This ensures we don't have to wait for incoming callbacks/requests from external sources.
  rasterSource->cancelActiveRequests();
 
  // At this point in time, only requests that are currently being processed can touch shared state, so
  // we wait until the processing is done before continuing.
  //
  //FIX: Perhaps this should be moved inside the cancellation function?
  while (rasterSource->hasProcessingRequests()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(0));
  }
 
  WriteLock lock(*rasterSource);
 
  rasterSource->purgeCache();
 
  clearLevels(rasterSource, clearContents);
}
 
void Cogs::ClipmapManager::invalidateTile(RasterSource * rasterSource, const RasterTileIdentifier & id)
{
  WriteLock lock(*rasterSource);
 
  rasterSource->invalidateTile(id);
}
 
namespace Cogs
{
  TextureOrigin updateOrigin(const Extent & currentExtent, const Extent & nextExtent, const int width, const int height, const TextureOrigin & origin)
  {
    int deltaX = nextExtent.west - currentExtent.west;
    int deltaY = nextExtent.south - currentExtent.south;
 
    if (deltaX == 0 && deltaY == 0)
      return origin;
 
    if (currentExtent.west > currentExtent.east || // initial update
      std::abs(deltaX) >= width || // complete update
      std::abs(deltaY) >= height) {
      return TextureOrigin(0, 0);
    } else {
      int newOriginX = (origin.x + deltaX) % width;
 
      if (newOriginX < 0)
        newOriginX += width;
 
      int newOriginY = (origin.y + deltaY) % height;
 
      if (newOriginY < 0)
        newOriginY += height;
 
      return TextureOrigin(newOriginX, newOriginY);
    }
  }
}
 
void Cogs::ClipmapManager::updateOriginInTextures(ClipmapLevel & level)
{
  level.origin = updateOrigin(level.currentExtent, level.nextExtent, level.renderTexture.width, level.renderTexture.height, level.origin);
}
 
void Cogs::ClipmapManager::updateClipmapLevels(RenderContext & context, const WorldOptions & worldOptions, const size_t maxLevel)
{
  Extent invalidExtent = { 1, 1, 0, 0 };
 
  for (size_t i = 0; i <= maxLevel; ++i) {
    updateClipmapLevel(context, worldOptions, terrainLevels[i], *terrainLevels[i].coarserLevel, parameters.precomputeNormals);
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      if (imageryEnabled[j]) {
        updateClipmapLevel(context, worldOptions, imagery[j][i], *imagery[j][i].coarserLevel, false);
      } else {
        imagery[j][i].currentExtent = invalidExtent;
      }
    }
  }
 
  // Ensure the levels that are not updated this frame receive full updates when
  // they are included back in the active set.
  for (size_t i = maxLevel + 1; i < terrainLevels.size(); ++i) {
    terrainLevels[i].currentExtent = invalidExtent;
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      imagery[j][i].currentExtent = invalidExtent;
    }
  }
}
 
void Cogs::ClipmapManager::updateClipmapLevel(RenderContext & context, const WorldOptions & worldOptions, ClipmapLevel & level, ClipmapLevel & /*coarserLevel*/, bool normal)
{
  int deltaX = level.nextExtent.west - level.currentExtent.west;
  int deltaY = level.nextExtent.south - level.currentExtent.south;
 
  if (deltaX == 0 && deltaY == 0 && !(normal && updateOptions.invalidateNormals)) {
    return;
  }
 
  int minLongitude = deltaX > 0 ? level.currentExtent.east + 1 : level.nextExtent.west;
  int maxLongitude = deltaX > 0 ? level.nextExtent.east : level.currentExtent.west - 1;
  int minLatitude = deltaY > 0 ? level.currentExtent.north + 1 : level.nextExtent.south;
  int maxLatitude = deltaY > 0 ? level.nextExtent.north : level.currentExtent.south - 1;
 
  int width = maxLongitude - minLongitude + 1;
  int height = maxLatitude - minLatitude + 1;
 
  if (level.currentExtent.west > level.currentExtent.east || // initial update
    width >= static_cast<int>(level.renderTexture.width) ||
    height >= static_cast<int>(level.renderTexture.height)) // complete update
  {
    // Initial or complete update.
    width = level.renderTexture.width;
    height = level.renderTexture.height;
    deltaX = level.renderTexture.width;
    deltaY = level.renderTexture.height;
    minLongitude = level.nextExtent.west;
    maxLongitude = level.nextExtent.east;
    minLatitude = level.nextExtent.south;
    maxLatitude = level.nextExtent.north;
  }
 
  if (height > 0)
  {
    ClipmapUpdate horizontalUpdate(
      &level,
      level.nextExtent.west,
      minLatitude,
      level.nextExtent.east,
      maxLatitude);
 
    updater.updateRasterLevel(context, &horizontalUpdate, 1);
 
    if (normal) {
      normalUpdater.updateNormalLevel(context, worldOptions, horizontalUpdate, normalLevels[level.index]);
    }
  }
 
  if (width > 0)
  {
    ClipmapUpdate verticalUpdate(
      &level,
      minLongitude,
      level.nextExtent.south,
      maxLongitude,
      level.nextExtent.north);
 
    updater.updateRasterLevel(context, &verticalUpdate, 1);
 
    if (normal) {
      normalUpdater.updateNormalLevel(context, worldOptions, verticalUpdate, normalLevels[level.index]);
    }
  }
 
  level.currentExtent = level.nextExtent;
 
  if (normal && updateOptions.invalidateNormals) {
    ClipmapUpdate update(
      &level,
      level.nextExtent.west,
      level.nextExtent.south,
      level.nextExtent.east,
      level.nextExtent.north);
 
    normalUpdater.updateNormalLevel(context, worldOptions, update, normalLevels[level.index]);
  }
}
 
void Cogs::ClipmapManager::updateBackgroundLevel(RenderContext & renderContext, const WorldOptions & worldOptions)
{
  backgroundLevel.nextExtent = backgroundLevel.rasterLevel->getIndexExtent();
  backgroundLevel.origin = TextureOrigin();
 
  if (parameters.precomputeNormals) {
    backgroundNormalLevel.nextExtent = backgroundLevel.nextExtent;
    backgroundNormalLevel.origin = TextureOrigin();
  }
 
  if (missingTileRegions != 0 || backgroundNeedsUpdate) {
    ClipmapUpdate update(
      &backgroundLevel,
      backgroundLevel.nextExtent.west,
      backgroundLevel.nextExtent.south,
      backgroundLevel.nextExtent.east,
      backgroundLevel.nextExtent.north);
 
    missingTileRegions = static_cast<int>(updater.updateRasterLevel(renderContext, &update, 1));
 
    if (parameters.precomputeNormals) {
      normalUpdater.updateNormalLevel(renderContext, worldOptions, update, backgroundNormalLevel);
    }
  }
 
  backgroundLevel.currentExtent = backgroundLevel.nextExtent;
 
  if (parameters.precomputeNormals) {
    backgroundNormalLevel.currentExtent = backgroundNormalLevel.nextExtent;
  }
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    if (missingImageryTileRegions.size() <= i)
      missingImageryTileRegions.push_back(1);
 
    if (missingImageryTileRegions[i] || backgroundNeedsUpdate) {
      auto & backgroundImageryLevel = backgroundImagery[i];
 
      updater.requestTileResidency(backgroundImageryLevel);
 
      Extent nextImageryExtent = {
        static_cast<int>(backgroundImageryLevel.rasterLevel->longitudeToIndex(backgroundLevel.rasterLevel->indexToLongitude(0))),
        static_cast<int>(backgroundImageryLevel.rasterLevel->latitudeToIndex(backgroundLevel.rasterLevel->indexToLatitude(0))),
        static_cast<int>(backgroundImageryLevel.rasterLevel->longitudeToIndex(backgroundLevel.rasterLevel->indexToLongitude(backgroundLevel.nextExtent.east))),
        static_cast<int>(backgroundImageryLevel.rasterLevel->latitudeToIndex(backgroundLevel.rasterLevel->indexToLatitude(backgroundLevel.nextExtent.north)))
      };
 
      backgroundImageryLevel.nextExtent = nextImageryExtent;
 
      backgroundImageryLevel.origin = TextureOrigin();
 
      ClipmapUpdate update(
        &backgroundImageryLevel,
        backgroundImageryLevel.nextExtent.west,
        backgroundImageryLevel.nextExtent.south,
        backgroundImageryLevel.nextExtent.east,
        backgroundImageryLevel.nextExtent.north);
 
      missingImageryTileRegions[i] = updater.updateRasterLevel(renderContext, &update, 1);
 
      backgroundImageryLevel.currentExtent = backgroundImageryLevel.nextExtent;
    }
  }
 
  backgroundNeedsUpdate = false;
}
 
void Cogs::ClipmapManager::updateMipmaps(size_t maxLevel, IGraphicsDevice * device)
{
  auto textures = device->getTextures();
 
  for (int i = static_cast<int>(maxLevel); i >= 0; --i) {
    for (size_t j = 0; j < imagery.size(); ++j) {
      textures->generateMipmaps(imagery[j][i].renderTexture.handle);
    }
  }
 
  for (size_t j = 0; j < imagery.size(); ++j) {
    textures->generateMipmaps(backgroundImagery[j].renderTexture.handle);
  }
}
 
void Cogs::ClipmapManager::requestTileLoads(RenderContext & /*renderContext*/, const size_t maxLevel)
{
  assert(maxLevel < terrainLevels.size());
 
  for (size_t i = 0; i <= maxLevel; ++i) {
    updater.requestTileResidency(terrainLevels[i]);
 
    for (size_t j = 0; j < imagerySources.size(); ++j) {
      if (imageryEnabled[j]) {
        updater.requestTileResidency(imagery[j][i]);
      }
    }
  }
 
  updater.requestTileResidency(backgroundLevel);
 
  for (size_t j = 0; j < imagerySources.size(); ++j) {
    if (imageryEnabled[j]) {
      updater.requestTileResidency(backgroundImagery[j]);
    }
  }
}
 
size_t Cogs::ClipmapManager::calculateCenterAndMaxLevel(RenderContext & renderContext)
{
  if (!terrainLevels.size()) {
    LOG_ERROR(logger, "Cannot calculate center and max levels with zero terrain levels.");
 
    return 0;
  }
 
  if (previousContext.offsetEnabled) {
    renderContext.distance = previousContext.distance;
    renderContext.center = previousContext.center;
  } else if (updateOptions.enableUpdate) {
    if (first) {
      renderContext.distance = std::numeric_limits<float>::max();
      renderContext.center = Vector3d(0, 0, 0);
      first = false;
    } else {
      if (worldOptions.centerPolicy == CenterCalculationPolicy::TerrainProjected) {
        const Matrix viewProjection = previousContext.scene.projectionMatrix * previousContext.scene.viewMatrix;
        const Matrix inverseViewProjection = glm::inverse(viewProjection);
 
        float xvalues[] = {0.5f, 0.45f, 0.55f, 0.4f, 0.6f, 0.35f, 0.65f, 0.3f, 0.7f, 0.25f, 0.75f, 0.2f, 0.8f, 0.15f, 0.85f, 0.1f, 0.9f, 0.05f, 0.95f};
        float yvaluesa[] = {0.5f, 0.45f, 0.4f, 0.35f, 0.3f, 0.25f, 0.2f, 0.15f, 0.1f, 0.05f};
        float yvaluesb[] = {0.55f, 0.6f, 0.65f, 0.7f, 0.75f, 0.8f, 0.85f, 0.9f, 0.95f};
 
        std::vector<Vector2> samplePositions;
        for(auto x : xvalues){
          for(auto y : yvaluesa){
            samplePositions.push_back(Vector2(x, y));
          }
        }
        for(auto x : xvalues){
          for(auto y : yvaluesb){
            samplePositions.push_back(Vector2(x, y));
          }
        }
 
        const size_t numSamples = samplePositions.size();
        std::vector<Vector4> center;
        std::vector<char> valid;
        center.resize(numSamples);
        valid.resize(numSamples);
 
        if (depthQuery.getPositions(samplePositions.data(), inverseViewProjection, numSamples, center.data(), (bool*)valid.data(), ClipmapRenderer::DefaultPickIndex)) {
          Vector3 viewCenter(0, 0, 0);
          viewCenter = vec3(glm::inverse(previousContext.scene.viewMatrix) * vec4(viewCenter, 1));
 
          renderContext.distance = std::numeric_limits<float>::max();
 
          Vector3 projectedCenter(0, 0, 0);
 
          for (size_t i = 0; i < numSamples; ++i) {
            if (valid[i]) {
              const Vector3 sampleCenter(center[i]);
 
              const float distance = glm::length(sampleCenter - viewCenter);
 
              if (distance < renderContext.distance) {
                renderContext.distance = distance;
                renderContext.sampleCenter = sampleCenter;
                projectedCenter = sampleCenter;
              }
            }
          }
 
          // Move camera center to global origin.
          projectedCenter += Vector3(previousContext.origin);
 
          // Translate back to clipmap coordinates from offset.
          projectedCenter -= Vector3(renderContext.offset);
 
          // Set clipmap center to scaled map coordinates.
          clipmapState.clipmapCenter = glm::dvec3(projectedCenter[0] * (1.0f / worldOptions.worldScale[0]), projectedCenter[1] * (1.0f / worldOptions.worldScale[1]), 0);
 
          // Clipmap center in world coordinates.
          renderContext.center = Vector3d(projectedCenter[0], projectedCenter[1], 0);
 
          renderContext.sampleOrigin = previousContext.origin;
 
          Vector3d cameraCenter = Vector3d(viewCenter) + previousContext.origin;
          renderContext.sampleCameraCenter = cameraCenter;
        } else {
          Vector3 viewCenter = Vector3(glm::inverse(previousContext.scene.viewMatrix) * vec4(0, 0, 0, 1));
          Vector3d cameraCenter = Vector3d(viewCenter) + previousContext.origin;
 
          Vector3 cameraDiff = Vector3(cameraCenter-renderContext.sampleCameraCenter);
 
          const float distance = glm::length(renderContext.sampleCenter - viewCenter);
          renderContext.distance = distance;
 
          Vector3 projectedCenter = renderContext.sampleCenter;
 
          // Move camera center to global origin.
          projectedCenter += Vector3(renderContext.sampleOrigin);
 
          // Translate back to clipmap coordinates from offset.
          projectedCenter -= Vector3(renderContext.offset);
 
          projectedCenter += cameraDiff;
 
          // Set clipmap center to scaled map coordinates.
          clipmapState.clipmapCenter = glm::dvec3(projectedCenter[0] * (1.0f / worldOptions.worldScale[0]), projectedCenter[1] * (1.0f / worldOptions.worldScale[1]), 0);
 
          // Clipmap center in world coordinates.
          renderContext.center = Vector3d(projectedCenter[0], projectedCenter[1], 0);
        }
      } else if (worldOptions.centerPolicy == CenterCalculationPolicy::Vertical) {
        Vector3 viewCenter = Vector3(glm::inverse(previousContext.scene.viewMatrix) * vec4(0, 0, 0, 1));
 
        Vector3 cameraCenter = viewCenter + Vector3(previousContext.origin);
 
        // Translate back to clipmap coordinates from offset.
        cameraCenter -= Vector3(renderContext.offset);
 
        // Set clipmap center to scaled map coordinates.
        clipmapState.clipmapCenter = glm::dvec3(cameraCenter.x * (1.0f / worldOptions.worldScale.x), cameraCenter.y * (1.0f / worldOptions.worldScale.y), 0);
 
        // Clipmap center in world coordinates.
        renderContext.center = Vector3d(cameraCenter.x, cameraCenter.y, 0);
        renderContext.distance =  std::fabs(cameraCenter.z);
      }
    }
  } else {
    renderContext.center = previousContext.center;
    renderContext.distance = previousContext.distance;
  }
 
  const auto & extent = terrainLevels[0].currentExtent;
 
  if (extent.west != 1 || extent.east != 0) {
    const float width = static_cast<float>((extent.east - extent.west) * terrainLevels[0].rasterLevel->getPostDeltaLongitude() * worldOptions.worldScale.x);
    float visibleWidth;
 
    if (renderContext.scene.projectionMatrix[3][3] == 1) {
      //orthographic camera. Get the distance between the left and right plan in frustum (both distances below are positive values)
      visibleWidth = renderContext.cullVolume.frustum.planes[0].distance + renderContext.cullVolume.frustum.planes[1].distance;
    } else {
      //perspective camera
      float fieldOfView = std::atan(1 / renderContext.scene.projectionMatrix[1][1]) * 2;
      visibleWidth = renderContext.distance * std::sin(fieldOfView) * 2.0f;
    }
 
    const float factor = width / visibleWidth;
    //Note : In earlier versions we used a hard coded value for field of view = pi/6. Since most cameras actually used field of view = pi/4, we increase
    //the used lodBias here to get same level of detail as before.
    float lodBias = renderOptions.lodBias + 0.3465735903f; //magic number is ln(sin(pi/4)/sin(pi/6))
 
    size_t maxLevel = static_cast<size_t>(std::max(lodBias + std::log(factor) / std::log(2.0f), 0.0f));
    maxLevel = std::max(static_cast<size_t>(0), std::min(maxLevel, terrainLevels.size() - 1));
 
    if (maxLevel < lastMaxLevel) {
      // When zooming out we want to keep the current detail level visible at greater distance than
      // the threshold for enabling it. This makes the detail level selection more stable, keeping levels
      // just popping in from immediately popping out e.g. due to small differences in terrain height.
      // compute corresponding factors for current level and one higher and compare with current factor
      const float thresholdAboveFactor = std::pow(2.0f, static_cast<float>(maxLevel - lodBias));
      const float thresholdBelowFactor = std::pow(2.0f, static_cast<float>(maxLevel + 1 - lodBias));
 
      const float fraction = (thresholdBelowFactor - factor) / (thresholdBelowFactor - thresholdAboveFactor);
 
      if (fraction < 0.25f) {
        // When the camera has not yet moved far into current threshold interval
        // keep the more detailed level.
        maxLevel = std::min(maxLevel + 1, terrainLevels.size() - 1);
      }
    }
 
    lastMaxLevel = maxLevel;
  }
 
  {
    // Clamp clipmap center so that the current most detailed level is never outside the geographic extents
    // of the raster data.
    const auto & mostDetailedLevel = terrainLevels[lastMaxLevel];
    const auto & rasterLevel = mostDetailedLevel.rasterLevel;
    const auto & rasterGeoExtent = rasterLevel->getGeoExtent();
 
    const double xOffset = static_cast<double>(parameters.clipmapPosts / 2) * rasterLevel->getPostDeltaLongitude();
    const double minX = rasterGeoExtent.getWest() + xOffset;
    const double maxX = rasterGeoExtent.getEast() - xOffset;
 
    const double yOffset = static_cast<double>(parameters.clipmapPosts / 2) * rasterLevel->getPostDeltaLatitude();
    const double minY = rasterGeoExtent.getSouth() + yOffset;
    const double maxY = rasterGeoExtent.getNorth() - yOffset;
 
    clipmapState.clipmapCenter.x = glm::clamp(clipmapState.clipmapCenter.x, minX, maxX);
    clipmapState.clipmapCenter.y = glm::clamp(clipmapState.clipmapCenter.y, minY, maxY);
  }
 
  return lastMaxLevel;
}
 
void Cogs::ClipmapManager::preloadLevelZeroTiles()
{
  if (!terrainLevels.size()) return;
 
  LOG_DEBUG(logger, "Preloading tiles...");
 
  auto & terrainLevel = terrainLevels[0];
 
  Extent extent = { 0, 0, terrainLevel.rasterLevel->getLongitudePosts() - 1, terrainLevel.rasterLevel->getLatitudePosts() - 1 };
  updater.preloadTiles(terrainLevel, extent);
 
  for (size_t i = 0; i < imagerySources.size(); ++i) {
    if (imageryEnabled[i]) {
      auto & imageryLevel = imagery[i][0];
 
      Extent imageryExtent = {
        static_cast<int>(imageryLevel.rasterLevel->longitudeToIndex(terrainLevel.rasterLevel->indexToLongitude(0))),
        static_cast<int>(imageryLevel.rasterLevel->latitudeToIndex(terrainLevel.rasterLevel->indexToLatitude(0))),
        static_cast<int>(imageryLevel.rasterLevel->longitudeToIndex(terrainLevel.rasterLevel->indexToLongitude(extent.east))),
        static_cast<int>(imageryLevel.rasterLevel->latitudeToIndex(terrainLevel.rasterLevel->indexToLatitude(extent.north)))
      };
 
      updater.preloadTiles(imageryLevel, imageryExtent);
    }
  }
}
 
void Cogs::ClipmapManager::clearLevels(RasterSource * rasterSource, bool clearContents)
{
  auto clearLevel = [&](ClipmapLevel & level) {
    if (level.rasterLevel != nullptr && level.rasterLevel->getSource() == rasterSource) {
      if (clearContents) {
        Cogs::clearClipmapTexture(device, level.renderTexture);
      }
 
      if (level.normalLevel) {
        if (clearContents) {
          Cogs::clearClipmapTexture(device, level.normalLevel->renderTexture);
        }
      }
    }
 
    Extent invalidExtent = { 1, 1, 0, 0 };
    level.currentExtent = invalidExtent;
  };
 
  for (auto & terrainLevel : terrainLevels) {
    clearLevel(terrainLevel);
  }
 
  for (auto & layer : imagery) {
    for (auto & imageryLevel : layer) {
      clearLevel(imageryLevel);
    }
  }
 
  clearLevel(backgroundLevel);
 
  for (auto & level : backgroundImagery) {
    clearLevel(level);
  }
 
  backgroundNeedsUpdate = true;
}
 
Cogs::RenderTexture Cogs::ClipmapManager::createTexture(const size_t width, const size_t height, const TextureFormat textureFormat, const bool mipmapping, glm::vec4 clearColor)
{
  auto texture = Cogs::createClipmapTexture(device, static_cast<int>(width), static_cast<int>(height), textureFormat, mipmapping && enableMipMapping, clearColor);
 
  metrics.clipmapTextureBuffer += texture.size;
 
  return texture;
}
 
void Cogs::ClipmapManager::destroyTexture(RenderTexture & texture)
{
  metrics.clipmapTextureBuffer -= texture.size;
 
  Cogs::releaseClipmapTexture(device, texture);
}
 
void Cogs::ClipmapManager::updateSharedDevice(IGraphicsDevice * device)
{
  if (terrainSource.isReady()) {
    terrainSource->device = device;
 
    for (size_t i = 0; i < imagerySources.size(); ++i) {
      imagerySources[i]->device = device;
    }
  }
}
 
void Cogs::ClipmapManager::renderDebugOverlays(RenderContext & renderContext)
{
  CommandGroupAnnotation debugGroup(renderContext.context, "Terrain::renderDebugOverlays");
 
  if (debugOptions.showDepthBuffer || debugOptions.showHeightMaps || debugOptions.showTextures) {
    const int sizeX = static_cast<int>(debugOptions.textureOverlaySize[0]);
    const int sizeY = static_cast<int>(debugOptions.textureOverlaySize[1]);
 
    const int screenHeight = renderContext.height;
    int xIndex = 0;
    int yIndex = 1;
 
    const int numX = renderContext.width / sizeX;
 
    if (debugOptions.showDepthBuffer) {
      for (auto & data : clipmapRenderer.raypickDepthData) {
        ClipmapDebug::displayClipmapTexture(device, data.depthTextureHandle, xIndex++ * sizeX, screenHeight - yIndex * sizeY, sizeX, sizeY);
        if (xIndex > numX) {
          xIndex = 0;
          yIndex++;
        }
      }
      ClipmapDebug::displayClipmapTexture(device, clipmapRenderer.depthQueryTextureHandle, xIndex++ * sizeX, screenHeight - yIndex * sizeY, sizeX, sizeY);
    }
 
    if (debugOptions.showHeightMaps) {
      for (size_t i = 0; i < terrainLevels.size(); ++i) {
        ClipmapDebug::displayClipmapTexture(device, terrainLevels[i].renderTexture.handle, xIndex++ * sizeX, screenHeight - yIndex * sizeY, sizeX, sizeY, 0.0005f);
 
        if (xIndex > numX) {
          xIndex = 0;
          yIndex++;
        }
      }
    }
 
    if (debugOptions.showTextures) {
      for (size_t i = 0; i < imagery[0].size(); ++i) {
        ClipmapDebug::displayClipmapTexture(device, imagery[0][i].renderTexture.handle, xIndex++ * sizeX, screenHeight - yIndex * sizeY, sizeX, sizeY);
 
        if (xIndex > numX) {
          xIndex = 0;
          yIndex++;
        }
      }
    }
  }
}
 
float Cogs::ClipmapManager::getNearestSample()
{
  if (isInitialized()) {
    const Matrix inverseProjection = glm::inverse(previousContext.scene.projectionMatrix);
 
    nearestSample = depthQuery.getNearestTerrainSample(inverseProjection);
    //nearestSample = depthQuery.getNearestTerrainSample2(inverseProjection, previousContext.scene.viewMatrix);
  }
 
  return nearestSample;
}