ClipmapUpsampler.cpp

#include "ClipmapUpsampler.h"
#include "ClipmapLevel.h"
#include "Effects.h"
#include "RenderContext.h"
#include "Raster/RasterSource.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IEffects.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IRenderTargets.h"
 
#include <cassert>
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ClipmapUpsampler");
 
  struct LevelParameters
  {
    glm::mat4 projectionMatrix;
    glm::vec2 oneOverTextureSize;
    glm::vec2 coarseRatio;
  };
 
  struct UpsampleParameters
  {
    glm::vec2 sourceOrigin;
    glm::vec2 updateSize;
    glm::vec2 destinationOffset;
 
    float noData;
    int enableNoData;
  };
 
  struct UpsampleTileParameters
  {
    glm::mat4 projectionMatrix;
    glm::vec2 sourceOrigin;
  };
}
 
void Cogs::ClipmapUpsampler::initialize(IGraphicsDevice * device)
{
  IEffects * effects = device->getEffects();
 
  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);
 
  LOG_DEBUG(logger, "Loading clipmap upsample effect.");
 
  upsampleEffectHandle = Terrain::EffectLoader::loadEffect(effects, "ClipmapUpsampleVS", "ClipmapUpsamplePS");
 
  if (!HandleIsValid(upsampleEffectHandle)) {
    LOG_ERROR(logger, "Error loading clipmap upsample effect.");
 
    return;
  }
  assert(effects->checkEffect(upsampleEffectHandle) == Cogs::ResourceStatus::Ready && "Expects synchronous effect loading");
 
  coarseImageryBinding = effects->getTextureBinding(upsampleEffectHandle, "coarseImagery", 0);
  coarseImagerySamplerBinding = effects->getSamplerStateBinding(upsampleEffectHandle, "coarseImagerySampler", 0);
 
  levelParameterBinding = effects->getConstantBufferBinding(upsampleEffectHandle, "LevelParameters");
  levelParameterBufferHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(LevelParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  upsampleParameterBinding = effects->getConstantBufferBinding(upsampleEffectHandle, "UpsampleParameters");
  upsampleParameterBufferHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(UpsampleParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  upsampleLayoutHandle = device->getBuffers()->loadInputLayout(&positionFormat, 1, upsampleEffectHandle);
 
  LOG_DEBUG(logger, "Loading clipmap upsample tile effect.");
 
  upsampleTileEffectHandle = Terrain::EffectLoader::loadEffect(effects, "ClipmapUpsampleTileVS", "ClipmapUpsampleTilePS");
  assert(effects->checkEffect(upsampleTileEffectHandle) == Cogs::ResourceStatus::Ready && "Expects synchronous effect loading");
 
  upsampleTileLayoutHandle = device->getBuffers()->loadInputLayout(&positionFormat, 1, upsampleTileEffectHandle);
 
  upsampleTileParameterBinding = effects->getConstantBufferBinding(upsampleTileEffectHandle, "UpsampleTileParameters");
  upsampleTileParameterBufferHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(UpsampleTileParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  SamplerState linearRepeatState = {
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::FilterMode::MinMagMipLinear,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  linearRepeatStateHandle = device->getTextures()->loadSamplerState(linearRepeatState);
 
  SamplerState pointRepeatState = {
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::FilterMode::MinMagMipPoint,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  pointRepeatStateHandle = device->getTextures()->loadSamplerState(pointRepeatState);
 
  SamplerState linearClampState = {
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::AddressMode::Clamp,
    SamplerState::FilterMode::MinMagMipLinear,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  linearClampStateHandle = device->getTextures()->loadSamplerState(linearClampState);
}
 
void Cogs::ClipmapUpsampler::upsampleLevelRegions(RenderContext & renderContext,
                                                  ClipmapLevel * level,
                                                  const RasterTileRegion ** regions,
                                                  const size_t numRegions)
{
  IContext * context = renderContext.context;
 
  ClipmapLevel * coarserLevel = level->coarserLevel;
 
  if (coarserLevel == nullptr || !numRegions) {
    return;
  }
 
  const RenderTexture * levelTexture = &level->renderTexture;
  const RenderTexture * coarserLevelTexture = &coarserLevel->renderTexture;
 
  if (coarserLevelTexture == levelTexture) return;
 
  const TextureOrigin & originInTextures = level->origin;
  const TextureOrigin & coarserOriginInTextures = coarserLevel->origin;
 
  const Extent & nextExtent = level->nextExtent;
  const Extent & coarserNextExtent = coarserLevel->nextExtent;
 
  const float noData = level->rasterLevel->getNoData();
  const bool enableNoData = !std::isnan(noData);
 
  const double ratioX = level->rasterLevel->getPostDeltaLongitude() / coarserLevel->rasterLevel->getPostDeltaLongitude();
  const double ratioY = level->rasterLevel->getPostDeltaLatitude() / coarserLevel->rasterLevel->getPostDeltaLatitude();
 
  context->setRenderTarget(levelTexture->renderTarget, DepthStencilHandle::InvalidHandle);
 
  context->setEffect(upsampleEffectHandle);
 
  const float width = static_cast<float>(levelTexture->width);
  const float height = static_cast<float>(levelTexture->height);
 
  Matrix projection = glm::ortho<float>(0, width, 0, height, -1.0f, 1.0f);
 
  context->setViewport(0, 0, width, height);
 
  const uint32_t strides[] = { 2 * sizeof(float) };
  context->setVertexBuffers(&vertexBufferHandle, 1, strides, nullptr);
  context->setInputLayout(upsampleLayoutHandle);
 
  context->setConstantBuffer(levelParameterBinding, levelParameterBufferHandle);
  context->setConstantBuffer(upsampleParameterBinding, upsampleParameterBufferHandle);
 
  context->setTexture(coarseImageryBinding, coarserLevelTexture->handle);
  context->setSamplerState(coarseImagerySamplerBinding, enableNoData ? pointRepeatStateHandle : linearRepeatStateHandle);
 
  const int fineClipmapWidth = nextExtent.getWidth();
  const int fineClipmapHeight = nextExtent.getHeight();
 
  const int coarseClipmapWidth = coarserNextExtent.getWidth();
  const int coarseClipmapHeight = coarserNextExtent.getHeight();
 
  const glm::vec2 oneOverTextureSize = { 1.0f / coarserLevelTexture->width, 1.0f / coarserLevelTexture->height };
  const glm::vec2 coarseRatio = { static_cast<float>(ratioX), static_cast<float>(ratioY) };
 
  {
    MappedBuffer<LevelParameters> levelParameters(context, levelParameterBufferHandle, MapMode::WriteDiscard);
 
    if (levelParameters) {
      levelParameters->projectionMatrix = projection;
      levelParameters->oneOverTextureSize = oneOverTextureSize;
      levelParameters->coarseRatio = coarseRatio;
    }
  }
 
  for (size_t i = 0; i < numRegions; ++i) {
    const RasterTileRegion * region = regions[i];
 
    const int destWest = (originInTextures[0] + (region->tile->extent.west + region->extent.west - nextExtent.west)) % fineClipmapWidth;
    const int destSouth = (originInTextures[1] + (region->tile->extent.south + region->extent.south - nextExtent.south)) % fineClipmapHeight;
 
    const double sourceWest = (int)(coarserOriginInTextures.x + ((region->tile->extent.west + region->extent.west) * ratioX - coarserNextExtent.west)) % coarseClipmapWidth;
    const double sourceSouth = (int)(coarserOriginInTextures.y + ((region->tile->extent.south + region->extent.south) * ratioY - coarserNextExtent.south)) % coarseClipmapHeight;
 
    const int regionWidth = region->extent.getWidth();
    const int regionHeight = region->extent.getHeight();
 
    const glm::vec2 sourceOrigin = { static_cast<float>(sourceWest), static_cast<float>(sourceSouth) };
    const glm::vec2 updateSize = { static_cast<float>(regionWidth), static_cast<float>(regionHeight) };
    const glm::vec2 destinationOffset = { static_cast<float>(destWest), static_cast<float>(destSouth) };
 
    {
      MappedBuffer<UpsampleParameters> upsampleParameters(context, upsampleParameterBufferHandle, MapMode::WriteDiscard);
 
      if (upsampleParameters) {
        upsampleParameters->sourceOrigin = sourceOrigin;
        upsampleParameters->updateSize = updateSize;
        upsampleParameters->destinationOffset = destinationOffset;
 
        upsampleParameters->enableNoData = enableNoData;
        upsampleParameters->noData = noData;
      }
    }
 
    context->draw(PrimitiveType::TriangleList, 0, 6);
  }
 
  // Reset the binding since the level may be used as render target on the next draw call (using
  // the same effect so bindings may not be reset).
  context->setTexture(coarseImageryBinding, TextureHandle::NoHandle);
  context->setSamplerState(coarseImagerySamplerBinding, SamplerStateHandle::NoHandle);
}
 
namespace
{
  float linear(const float a, const float b, float amount)
  {
    return a * (1.0f - amount) + b * amount;
  }
}
 
Cogs::TextureHandle Cogs::ClipmapUpsampler::upsampleTile(RenderContext & renderContext, RasterSource * source, RasterTile * parentTile, RasterTile * tile)
{
  IContext * context = renderContext.context;
  IRenderTargets * renderTargets = renderContext.device->getRenderTargets();
 
  const auto tileId = tile->identifier;
 
  auto tileData = source->getTileData(tile);
  const auto parentTileData = source->getTileData(parentTile);
 
  if (!tileData || !parentTileData) {
    return TextureHandle::NoHandle;
  }
 
  const size_t width = static_cast<size_t>(tile->getWidth());
  const size_t height = static_cast<size_t>(tile->getHeight());
  const auto bpp = Cogs::getBlockSize(parentTileData->format);
  const auto textureSize = Cogs::getTextureSize(static_cast<int>(width), static_cast<int>(height), parentTileData->format);
 
  bool useMemCopyUpsample = true;
 
  if (useMemCopyUpsample) {
    if (!parentTileData->data.size() || tileData->textureHandle != TextureHandle::NoHandle) {
      return TextureHandle::NoHandle;
    }
    
    source->allocateTileStorage(textureSize, tileData->data);
 
    auto bytes = tileData->data.data();
    
    if (parentTileData->format == TextureFormat::R32_FLOAT) {
      const float * parentData = reinterpret_cast<float *>(parentTileData->data.data());
 
      for (size_t y = 0; y < height; ++y) {
        for (size_t x = 0; x < width; ++x) {
          size_t xx = x / 2 + ((tileId.x % 2) ? width / 2 : 0);
          size_t yy = y / 2 + ((tileId.y % 2) ? height / 2 : 0);
 
          float v1 = parentData[yy * width + xx];
          float v2 = parentData[yy * width + xx + ((xx < width - 1) ? 1 : 0)];
 
          float v3 = parentData[(yy + ((yy < height - 1) ? 1 : 0)) * width + xx];
          float v4 = parentData[(yy + ((yy < height - 1) ? 1 : 0)) * width + xx + ((xx < width - 1) ? 1 : 0)];
 
          ((float *)bytes)[y * width + x] = linear(
            linear(v1, v2, (x % 2) ? 0.5f : 0.0f),
            linear(v3, v4, (x % 2) ? 0.5f : 0.0f),
            (y % 2) ? 0.5f : 0.0f);
        }
      }
    } else {
      const auto parentBytes = parentTileData->data.data();
 
      for (size_t y = 0; y < height; ++y) {
        for (size_t x = 0; x < width; ++x) {
          size_t xx = x / 2 + ((tileId.x % 2) ? width / 2 : 0);
          size_t yy = y / 2 + ((tileId.y % 2) ? height / 2 : 0);
 
          std::memcpy(bytes + (y * width + x) * bpp, parentBytes + (yy * width + xx) * bpp, bpp);
        }
      }
    }
 
    auto tileTexture = source->loadTexture(bytes, static_cast<int>(width), static_cast<int>(height), parentTileData->format, textureSize);
 
    tileData->size = textureSize;
    tileData->format = parentTileData->format;
    tileData->textureHandle = tileTexture;
 
    return tileTexture;
  } else {
    auto tileTexture = source->loadTexture(nullptr, static_cast<int>(width), static_cast<int>(height), parentTileData->format, textureSize);
 
    auto renderTarget = renderTargets->createRenderTarget(&tileTexture, 1);
    auto depthTarget = renderTargets->createDepthStencilTarget(renderTarget);
 
    context->setRenderTarget(renderTarget, depthTarget);
 
    float color[] = { 0, 1, 0, 1, };
    context->clearRenderTarget(color);
 
    context->setEffect(upsampleTileEffectHandle);
 
    Matrix projection = glm::ortho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
    const float sourceOrigin[] = { (tileId.x % 2) ? 0.5f : 0.0f, (tileId.y % 2) ? 0.5f : 0.0f };
    {
      MappedBuffer<UpsampleTileParameters> upsampleTileParameters(context, upsampleTileParameterBufferHandle, MapMode::WriteDiscard);
      if (upsampleTileParameters) {
        upsampleTileParameters->projectionMatrix = projection;
        upsampleTileParameters->sourceOrigin.x = sourceOrigin[0];
        upsampleTileParameters->sourceOrigin.y = sourceOrigin[1];
      }
    }
    context->setConstantBuffer(upsampleTileParameterBinding, upsampleTileParameterBufferHandle);
 
    context->setViewport(0, 0, static_cast<float>(width), static_cast<float>(height));
 
    const uint32_t strides[] = { 2 * sizeof(float) };
    context->setVertexBuffers(&vertexBufferHandle, 1, strides, nullptr);
    context->setInputLayout(upsampleTileLayoutHandle);
 
    context->setTexture("coarseImagery", 0, parentTileData->textureHandle);
    context->setSamplerState("TextureSampler", 0, linearClampStateHandle);
 
    context->draw(PrimitiveType::TriangleList, 0, 6);
 
    tileData->size = textureSize;
    tileData->format = parentTileData->format;
    tileData->textureHandle = tileTexture;
    tileData->data.clear();
 
    renderTargets->releaseDepthStencilTarget(depthTarget);
    renderTargets->releaseRenderTarget(renderTarget);
 
    return tileTexture;
  }
}