NormalUpdater.cpp

#include "NormalUpdater.h"
#include "ClipmapUpdate.h"
#include "Effects.h"
#include "RenderContext.h"
#include "Raster/RasterLevel.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IEffects.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("NormalUpdater");
}
 
namespace Cogs
{
  struct NormalLevelParameters
  {
    Matrix projectionMatrix;
    Vector2 oneOverHeightMapSize;
 
    float heightExaggeration;
    float postDelta;
  };
 
  struct NormalUpdateParameters
  {
    Vector2 updateSize;
    Vector2 origin;
  };
}
 
void Cogs::NormalUpdater::initialize(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);
 
  IEffects * effects = device->getEffects();
 
  LOG_DEBUG(logger, "Loading climpap normal update effect.");
 
  computeNormalsEffectHandle = Terrain::EffectLoader::loadEffect(effects, "ClipmapComputeNormalsVS", "ClipmapComputeNormalsPS");
 
  if (!HandleIsValid(computeNormalsEffectHandle)) {
    LOG_ERROR(logger, "Error loading normal computation effect.");
 
    return;
  }
  assert(effects->checkEffect(computeNormalsEffectHandle) == Cogs::ResourceStatus::Ready && "Expects synchronous effect loading");
 
  auto buffers = device->getBuffers();
 
  computeNormalsLayoutHandle = device->getBuffers()->loadInputLayout(&positionFormat, 1, computeNormalsEffectHandle);
 
  normalLevelBuffer = buffers->loadBuffer(nullptr, sizeof(NormalLevelParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  normalLevelBinding = effects->getConstantBufferBinding(computeNormalsEffectHandle, "NormalLevelParameters");
 
  normalUpdateBuffer = buffers->loadBuffer(nullptr, sizeof(NormalUpdateParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  normalUpdateBinding = effects->getConstantBufferBinding(computeNormalsEffectHandle, "NormalUpdateParameters");
 
  SamplerState nearestRepeatState = {
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::FilterMode::MinMagMipPoint,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f }
  };
 
  nearestRepeatStateHandle = device->getTextures()->loadSamplerState(nearestRepeatState);
  samplerStateBinding = effects->getSamplerStateBinding(computeNormalsEffectHandle, std::string(), 0);
 
  levelTextureBinding = effects->getTextureBinding(computeNormalsEffectHandle, "heightTexture", 0);
}
 
void Cogs::NormalUpdater::updateNormalLevel(RenderContext & context, const WorldOptions & worldOptions, const ClipmapUpdate & clipmapUpdate, ClipmapLevel & normalLevel)
{
  // Normals at edges are incorrect, so include a one-post buffer around the update region
  // when updating normals in order to update normals that were previously at the edge.
  ClipmapUpdate updateWithBuffer = clipmapUpdate.addBufferWithinLevelNextExtent();
 
  static std::vector<ClipmapUpdate> normalUpdates;
 
  normalUpdates.clear();
 
  ClipmapUpdate::splitUpdateToAvoidWrapping(updateWithBuffer, normalUpdates);
 
  renderNormals(context, worldOptions, normalUpdates, normalLevel);
}
 
void Cogs::NormalUpdater::renderNormals(RenderContext & renderContext, const WorldOptions & worldOptions, const std::vector<ClipmapUpdate> & normalUpdates, ClipmapLevel & normalLevel)
{
  if (!normalUpdates.size() || !HandleIsValid(computeNormalsEffectHandle)) return;
 
  IContext * context = renderContext.context;
 
  const ClipmapLevel * terrainLevel = normalUpdates[0].getLevel();
  auto & nextExtent = terrainLevel->nextExtent;
 
  const float width = static_cast<float>(normalLevel.renderTexture.width);
  const float height = static_cast<float>(normalLevel.renderTexture.height);
 
  context->setRenderTarget(normalLevel.renderTexture.renderTarget, DepthStencilHandle::InvalidHandle);
  context->setViewport(0, 0, width, height);
 
  context->setEffect(computeNormalsEffectHandle);
 
  context->setTexture(levelTextureBinding, terrainLevel->renderTexture.handle);
  context->setSamplerState(samplerStateBinding, nearestRepeatStateHandle);
 
  const uint32_t strides[] = { 2 * sizeof(float) };
  context->setVertexBuffers(&vertexBufferHandle, 1, strides, nullptr);
  context->setInputLayout(computeNormalsLayoutHandle);
 
  context->setConstantBuffer(normalLevelBinding, normalLevelBuffer); 
  context->setConstantBuffer(normalUpdateBinding, normalUpdateBuffer);
 
  {
    MappedBuffer<NormalLevelParameters> levelParameters(context, normalLevelBuffer, MapMode::WriteDiscard);
 
    if (levelParameters) {
      levelParameters->heightExaggeration = worldOptions.heightExaggeration;
 
      levelParameters->projectionMatrix = glm::ortho<float>(0, static_cast<float>(nextExtent.east - nextExtent.west), 0, static_cast<float>(nextExtent.north - nextExtent.south), -1.0f, 1.0f);
 
      levelParameters->oneOverHeightMapSize = Vector2(
        1.0f / (float) (terrainLevel->nextExtent.east - terrainLevel->nextExtent.west + 1),
        1.0f / (float) (terrainLevel->nextExtent.north - terrainLevel->nextExtent.south + 1));
 
      levelParameters->postDelta = static_cast<float>(terrainLevel->rasterLevel->getPostDeltaLongitude() * worldOptions.worldScale.x);
    }
  }
 
  const int clipmapSize = terrainLevel->nextExtent.east - terrainLevel->nextExtent.west + 1;
 
  for (size_t i = 0; i < normalUpdates.size(); ++i) {
    const ClipmapUpdate & normalUpdate = normalUpdates[i];
 
    const int west = (terrainLevel->origin.x + (normalUpdate.getWest() - terrainLevel->nextExtent.west)) % clipmapSize;
    const int south = (terrainLevel->origin.y + (normalUpdate.getSouth() - terrainLevel->nextExtent.south)) % clipmapSize;
 
    {
      MappedBuffer<NormalUpdateParameters> updateParameters(context, normalUpdateBuffer, MapMode::WriteDiscard);
 
      if (updateParameters) {
        updateParameters->origin = Vector2(static_cast<float>(west), static_cast<float>(south));
        updateParameters->updateSize = Vector2(static_cast<float>(normalUpdate.getWidth()), static_cast<float>(normalUpdate.getHeight()));
      }
    }
 
    context->draw(PrimitiveType::TriangleList, 0, 6);
  }
}