ClipmapRenderer.cpp

#include "ClipmapRenderer.h"
 
#include "ClipmapLevel.h"
#include "ClipmapGeometry.h"
#include "ClipmapState.h"
#include "ClipmapParameterCalculation.h"
 
#include "RenderBlock.h"
#include "RenderBlockCulling.h"
 
#include "Rendering/IRenderTargets.h"
#include "Rendering/IContext.h"
#include "Rendering/ITextures.h"
#include "Rendering/IEffects.h"
 
#include <cassert>
 
namespace
{
  std::vector<Cogs::Vector3> colors = {
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
    Cogs::Vector3(0, 0, 1),
    Cogs::Vector3(1, 1, 0),
    Cogs::Vector3(0, 1, 1),
    Cogs::Vector3(1, 0, 1),
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
    Cogs::Vector3(0, 0, 1),
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
    Cogs::Vector3(0, 0, 1),
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
    Cogs::Vector3(0, 0, 1),
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
    Cogs::Vector3(0, 0, 1),
    Cogs::Vector3(1, 0, 0),
    Cogs::Vector3(0, 1, 0),
  };
}
 
void Cogs::DepthRenderData::initialize(IGraphicsDevice * device, int width, int height)
{
  this->width = width;
  this->height = height;
  auto textures = device->getTextures();
  auto renderTargets = device->getRenderTargets();
 
  depthTextureHandle = textures->loadTexture(nullptr, width, height, TextureFormat::R32_FLOAT, TextureFlags::RenderTarget);
 
  depthRenderHandle = renderTargets->createRenderTarget(depthTextureHandle);
  depthTargetHandle = renderTargets->createDepthStencilTarget(depthRenderHandle);
 
  const size_t bufferSize = width * height * sizeof(float);
  readbackBufferHandle = device->getBuffers()->loadBuffer(nullptr, bufferSize, Usage::Staging, AccessMode::Read, 0);
}
 
void Cogs::DepthRenderData::cleanup(IGraphicsDevice * device)
{
  auto textures = device->getTextures();
  auto renderTargets = device->getRenderTargets();
 
  renderTargets->releaseDepthStencilTarget(depthTargetHandle);
  renderTargets->releaseRenderTarget(depthRenderHandle);
 
  textures->releaseTexture(depthTextureHandle);
 
  device->getBuffers()->releaseBuffer(readbackBufferHandle);
}
 
void Cogs::ClipmapRenderer::initializeTextures(ITextures * textures)
{
  SamplerState pointSampler = {
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::FilterMode::MinMagMipPoint,
    SamplerState::ComparisonFunction::Never,
    0,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  pointSamplerState = textures->loadSamplerState(pointSampler);
 
  SamplerState linearSampler = {
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::AddressMode::Wrap,
    SamplerState::FilterMode::MinMagMipLinear,
    SamplerState::ComparisonFunction::Never,
    16,
    { 0.0f, 0.0f, 0.0f, 0.0f },
  };
 
  linearSamplerState = textures->loadSamplerState(linearSampler);
 
  depthQuerySize = 8;
  depthQueryTextureHandle = textures->loadTexture(nullptr, depthQuerySize, depthQuerySize, TextureFormat::R32G32B32A32_FLOAT, TextureFlags::RenderTarget);
}
 
void Cogs::ClipmapRenderer::initializeEffects(IBuffers * buffers, IEffects * effects, const size_t numImagery, size_t permutation)
{
  auto & permutationRendererData = getPermutationDependentClipmapRendererData(permutation);
  if (!permutationRendererData.initialized) {
    // First time, create and initialize constant buffers.
    initializeConstantBuffers(buffers, permutationRendererData.effectVariables);
    initializeConstantBuffers(buffers, permutationRendererData.depthEffectVariables);
  }
 
  initializeEffectVariables(effects, permutationRendererData.clipmapEffect, permutationRendererData.effectVariables, numImagery, false);
  initializeEffectVariables(effects, permutationRendererData.clipmapDepthEffect, permutationRendererData.depthEffectVariables, numImagery, true);
 
  initializeEffectBindings(effects, permutationRendererData.clipmapEffect, permutationRendererData.effectBindings, numImagery, false);
  initializeEffectBindings(effects, permutationRendererData.clipmapDepthEffect, permutationRendererData.depthEffectBindings, numImagery, true);
 
  VertexElement element = { 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 };
  VertexFormatHandle meshFormat = buffers->createVertexFormat(&element, 1);
  inputLayout = buffers->loadInputLayout(&meshFormat, 1, permutationRendererData.clipmapEffect);
 
  permutationRendererData.initialized = true;
}
 
void Cogs::ClipmapRenderer::initializeConstantBuffers(IBuffers * buffers, ClipmapEffectVariables & variables)
{
  variables.globalBuffer = buffers->loadBuffer(nullptr, sizeof(GlobalParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  variables.levelBuffer = buffers->loadBuffer(nullptr, sizeof(LevelParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  variables.imageryBuffer = buffers->loadBuffer(nullptr, sizeof(ImageryParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  variables.patchBuffer = buffers->loadBuffer(nullptr, sizeof(PatchParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
  variables.renderBuffer = buffers->loadBuffer(nullptr, sizeof(RenderParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  variables.levelRenderBuffer = buffers->loadBuffer(nullptr, sizeof(LevelRenderParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  customParametersBuffer = BufferHandle::NoHandle;
}
 
void Cogs::ClipmapRenderer::initializeEffectVariables(IEffects * effects, EffectHandle effectHandle, ClipmapEffectVariables & variables, const size_t /*numImagery*/, bool isDepth)
{
  variables.globalBufferBinding = effects->getConstantBufferBinding(effectHandle, "GlobalParameters");
  variables.levelBufferBinding = effects->getConstantBufferBinding(effectHandle, "LevelParameters");
 
  variables.patchBufferBinding = effects->getConstantBufferBinding(effectHandle, "PatchParameters");
  variables.imageryBufferBinding = effects->getConstantBufferBinding(effectHandle, "ImageryParameters");
 
  if (!isDepth) {
 
    variables.renderBufferBinding = effects->getConstantBufferBinding(effectHandle, "RenderParameters");
    variables.levelRenderBufferBinding = effects->getConstantBufferBinding(effectHandle, "LevelRenderParameters");
  }
 
  variables.customParametersBufferBinding = effects->getConstantBufferBinding(effectHandle, "CustomParameters");
}
 
namespace
{
  const char * imagerySemantics[] = {
    "imageryTexture[0]",
    "imageryTexture[1]",
    "imageryTexture[2]",
    "imageryTexture[3]",
  };
 
  const char * coarseImagerySemantics[] = {
    "coarseImageryTexture[0]",
    "coarseImageryTexture[1]",
    "coarseImageryTexture[2]",
    "coarseImageryTexture[3]",
  };
}
 
void Cogs::ClipmapRenderer::initializeEffectBindings(IEffects * effects, EffectHandle effect, ClipmapTextureBindings & bindings, const size_t numImagery, bool isDepth)
{
  int unit = 0;
 
  bindings.heightMapBinding = effects->getTextureBinding(effect, "heightTexture", unit);
  bindings.heightMapSamplerBinding = effects->getSamplerStateBinding(effect, "heightSampler", unit++);
 
  bindings.coarseHeightMapBinding = effects->getTextureBinding(effect, "coarseHeightTexture", unit);
  bindings.coarseHeightMapSamplerBinding = effects->getSamplerStateBinding(effect, "coarseHeightSampler", unit++);
 
  if (!isDepth || true) {
    bindings.normalMapBinding = effects->getTextureBinding(effect, "normalTexture", unit);
    bindings.normalMapSamplerBinding = effects->getSamplerStateBinding(effect, "normalSampler", unit++);
 
    bindings.coarseNormalMapBinding = effects->getTextureBinding(effect, "coarseNormalTexture", unit);
    bindings.coarseNormalMapSamplerBinding = effects->getSamplerStateBinding(effect, "normalSampler", unit++);
 
    if (numImagery > 1) {
      for (size_t i = 0; i < numImagery; ++i) {
        auto & perImageBindings = bindings.getImageryBindingHandles(i);
        perImageBindings.imageryBinding = effects->getTextureBinding(effect, imagerySemantics[i], unit);
        perImageBindings.imagerySamplerBinding = effects->getSamplerStateBinding(effect, "imagerySampler", unit++);
 
        perImageBindings.coarseImageryBinding = effects->getTextureBinding(effect, coarseImagerySemantics[i], unit);
        perImageBindings.coarseImagerySamplerBinding = effects->getSamplerStateBinding(effect, "imagerySampler", unit++);
      }
    } else {
      auto & perImageBindings = bindings.getImageryBindingHandles(0);
      perImageBindings.imageryBinding = effects->getTextureBinding(effect, "imageryTexture[0]", unit);
      perImageBindings.imagerySamplerBinding = effects->getSamplerStateBinding(effect, "imagerySampler", unit++);
 
      perImageBindings.coarseImageryBinding = effects->getTextureBinding(effect, "coarseImageryTexture[0]", unit);
      perImageBindings.coarseImagerySamplerBinding = perImageBindings.imagerySamplerBinding;
    }
  }
}
 
void Cogs::ClipmapRenderer::initializeRasterizerStates(IRenderTargets * renderTargets)
{
  float offset = reverseDepth ? -1.0f : 1.0f;
  DepthStencilState::DepthFunction cmp = reverseDepth ? DepthStencilState::Greater : DepthStencilState::Less;
  DepthStencilState::DepthFunction cmpOrEqual = reverseDepth ? DepthStencilState::GreaterOrEqual : DepthStencilState::LessOrEqual;
 
  RasterizerState solid = { false, RasterizerState::CullMode::None, true, true, 0.0f, 0.0f, 0.0f, false, false };
  solidRasterizerState = renderTargets->loadRasterizerState(solid);
 
  RasterizerState solidNoDepthClip = { false, RasterizerState::CullMode::None, true, true, 0.0f, 0.0f, 0.0f, false, false };
  solidNoDepthClip.noDepthClip = true;
  solidNoDepthClipRasterizerState = renderTargets->loadRasterizerState(solidNoDepthClip);
 
  RasterizerState solidOffset = { false, RasterizerState::CullMode::None, true, true, offset, 0.0f, 0.0f, false, false };
  solidOffsetRasterizerState = renderTargets->loadRasterizerState(solidOffset);
 
  RasterizerState wireFrame = { true, RasterizerState::CullMode::None, true, true, 0.0f, 0.0f, 0.0f, false, false };
  wireframeRasterizerState = renderTargets->loadRasterizerState(wireFrame);
 
  DepthStencilState solidDepth = { true, true, cmp };
  solidDepthState = renderTargets->loadDepthStencilState(solidDepth);
 
  DepthStencilState wireDepth = { true, true, cmpOrEqual };
  wireframeDepthState = renderTargets->loadDepthStencilState(wireDepth);
 
  DepthStencilState transparentDepth = { true, false, cmp };
  transparentDepthState = renderTargets->loadDepthStencilState(transparentDepth);
 
  DepthStencilState transparentWireDepth = { true, false, cmpOrEqual };
  transparentWireframeDepthState = renderTargets->loadDepthStencilState(transparentWireDepth);
}
 
void Cogs::ClipmapRenderer::initializeRenderTargets(IRenderTargets * renderTargets)
{
  depthQueryRenderHandle = renderTargets->createRenderTarget(depthQueryTextureHandle);
  depthQueryTargetHandle = renderTargets->createDepthStencilTarget(depthQueryRenderHandle);
}
 
namespace Cogs
{
  template<typename Parameters>
  void applyParameters(IContext * context, const Parameters & parameters, BufferHandle bufferHandle)
  {
    MappedBuffer<Parameters> out(context, bufferHandle, MapMode::WriteDiscard);
 
    if (out) {
      ::memcpy(out, &parameters, sizeof(Parameters));
    }
  }
}
 
void Cogs::ClipmapRenderer::updateGlobalParameters(const RenderContext & renderContext, const RenderOptions & renderOptions, const ClipmapState & /*clipmapState*/, const GlobalParameters & globalParameters)
{
  IContext * context = renderContext.context;
 
  const auto & permutationRendererData = getPermutationDependentClipmapRendererData(renderContext.permutation);
  const auto & variables = this->depthPass ? permutationRendererData.depthEffectVariables : permutationRendererData.effectVariables;
 
  if (!this->depthPass) {
    RenderParameters renderParameters;
    renderParameters.blendRegionColor = renderOptions.blendRegionColor;
    renderParameters.showBlendRegions = renderOptions.showBlendRegions;
    renderParameters.showImagery = renderOptions.showImagery;
    renderParameters.showLevelColors = renderOptions.showLevelColors;
 
    applyParameters(context, renderParameters, variables.renderBuffer);
  }
 
  applyParameters(context, globalParameters, variables.globalBuffer);
}
 
void Cogs::ClipmapRenderer::updateLevelParameters(IContext * context, const RenderOptions & options, const LevelParameters & parameters, const ImageryParameters & imageryParameters, size_t permutation)
{
  const auto & permutationRendererData = getPermutationDependentClipmapRendererData(permutation);
  const auto & variables = this->depthPass ? permutationRendererData.depthEffectVariables : permutationRendererData.effectVariables;
 
  applyParameters(context, parameters, variables.levelBuffer);
  applyParameters(context, imageryParameters, variables.imageryBuffer);
 
  if (options.showLevelColors && !this->depthPass) {
    Vector4 diffuseColor = pad3to4(colors[parameters.levelIndex & colors.size()]);
    applyParameters(context, diffuseColor, variables.levelRenderBuffer);
  } else if (!this->depthPass) {
    applyParameters(context, options.diffuseColor, variables.levelRenderBuffer);
  }
}
 
void Cogs::ClipmapRenderer::updateLevelTextures(IContext * context,
                                                const RenderLevel * renderLevel,
                                                size_t permutation)
{
  auto & permutationRendererData = getPermutationDependentClipmapRendererData(permutation);
  auto & bindings = this->depthPass ? permutationRendererData.depthEffectBindings : permutationRendererData.effectBindings;
 
  context->setTexture(bindings.heightMapBinding, renderLevel->terrainLevel->renderTexture.handle);
  context->setSamplerState(bindings.heightMapSamplerBinding, pointSamplerState);
 
  context->setTexture(bindings.coarseHeightMapBinding, renderLevel->coarserTerrainLevel->renderTexture.handle);
  context->setSamplerState(bindings.coarseHeightMapSamplerBinding, linearSamplerState);
 
  if (!this->depthPass || true) {
    if (renderLevel->normalLevel) {
      context->setTexture(bindings.normalMapBinding, renderLevel->normalLevel->renderTexture.handle);
      context->setSamplerState(bindings.normalMapSamplerBinding, linearSamplerState);
 
      context->setTexture(bindings.coarseNormalMapBinding, renderLevel->coarserNormalLevel->renderTexture.handle);
      context->setSamplerState(bindings.coarseNormalMapSamplerBinding, linearSamplerState);
    }
 
    const size_t levelIndex = renderLevel->terrainLevel->index;
 
    for (size_t i = 0; i < renderLevel->imagery->size(); ++i) {
      const ClipmapLevel & imageryLevel = (*renderLevel->imagery)[i][levelIndex];
      const auto & perImageBindings = bindings.getImageryBindingHandles(i);
 
      context->setTexture(perImageBindings.imageryBinding, imageryLevel.renderTexture.handle);
      context->setSamplerState(perImageBindings.imagerySamplerBinding, linearSamplerState);
 
      context->setTexture(perImageBindings.coarseImageryBinding, imageryLevel.coarserLevel->renderTexture.handle);
      context->setSamplerState(perImageBindings.coarseImagerySamplerBinding, linearSamplerState);
    }
  }
}
 
void Cogs::ClipmapRenderer::initLevels()
{
  levelIndex = 0;
}
 
bool Cogs::ClipmapRenderer::createRenderLevel(ClipmapGeometry & geometry,
                                        ClipmapState & clipmapState,
                                        ClipmapLevel & terrainLevel,
                                        std::vector<std::vector<ClipmapLevel>> & imagery,
                                        ClipmapLevel * normalLevel,
                                        const GlobalParameters & globalParameters,
                                        const LevelParameters & parameters,
                                        const ImageryParameters & imageryParameters,
                                        bool fillRing,
                                        bool select)
{
  this->geometry = &geometry;
 
  const int west = terrainLevel.currentExtent.west;
  const int south = terrainLevel.currentExtent.south;
  const int east = terrainLevel.currentExtent.east;
  const int north = terrainLevel.currentExtent.north;
 
  const int fillPatchSegments = static_cast<int>(clipmapState.fillPatchSegments);
  const int fillPatchPosts = static_cast<int>(clipmapState.fillPatchPosts);
 
  RenderLevel & renderLevel = levels[levelIndex++];
 
  renderLevel.globalParameters = &globalParameters;
  renderLevel.levelParameters = &parameters;
  renderLevel.imageryParameters = &imageryParameters;
 
  renderLevel.terrainLevel = &terrainLevel;
  renderLevel.coarserTerrainLevel = terrainLevel.coarserLevel;
 
  renderLevel.imagery = &imagery;
 
  renderLevel.normalLevel = normalLevel;
  renderLevel.coarserNormalLevel = normalLevel ? normalLevel->coarserLevel : nullptr;
 
  renderLevel.blockCount = 0;
 
  createBlock(geometry.fieldBlockMesh, west, south, west, south, renderLevel, select);
 
  createBlock(geometry.fieldBlockMesh, west, south, west + fillPatchSegments, south, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - 2 * fillPatchSegments, south, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - fillPatchSegments, south, renderLevel, select);
 
  createBlock(geometry.fieldBlockMesh, west, south, west, south + fillPatchSegments, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - fillPatchSegments, south + fillPatchSegments, renderLevel, select);
 
  createBlock(geometry.fieldBlockMesh, west, south, west, north - 2 * fillPatchSegments, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - fillPatchSegments, north - 2 * fillPatchSegments, renderLevel, select);
 
  createBlock(geometry.fieldBlockMesh, west, south, west, north - fillPatchSegments, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, west + fillPatchSegments, north - fillPatchSegments, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - 2 * fillPatchSegments, north - fillPatchSegments, renderLevel, select);
  createBlock(geometry.fieldBlockMesh, west, south, east - fillPatchSegments, north - fillPatchSegments, renderLevel, select);
 
  createBlock(geometry.ringFixupHorizontalMesh, west, south, west, south + 2 * fillPatchSegments, renderLevel);
  createBlock(geometry.ringFixupHorizontalMesh, west, south, east - fillPatchSegments, south + 2 * fillPatchSegments, renderLevel);
 
  createBlock(geometry.ringFixupVerticalMesh, west, south, west + 2 * fillPatchSegments, south, renderLevel);
  createBlock(geometry.ringFixupVerticalMesh, west, south, west + 2 * fillPatchSegments, north - fillPatchSegments, renderLevel);
 
  createBlock(geometry.degenerateTriangleMesh, west, south, west, south, renderLevel);
 
  // Fill the center of the highest-detail ring
  if (fillRing) {
    createBlock(geometry.fieldBlockMesh, west, south, west + fillPatchSegments, south + fillPatchSegments, renderLevel);
    createBlock(geometry.fieldBlockMesh, west, south, west + 2 * fillPatchPosts, south + fillPatchSegments, renderLevel);
    createBlock(geometry.fieldBlockMesh, west, south, west + fillPatchSegments, south + 2 * fillPatchPosts, renderLevel);
    createBlock(geometry.fieldBlockMesh, west, south, west + 2 * fillPatchPosts, south + 2 * fillPatchPosts, renderLevel);
 
    createBlock(geometry.ringFixupHorizontalMesh, west, south, west + fillPatchSegments, south + 2 * fillPatchSegments, renderLevel);
    createBlock(geometry.ringFixupHorizontalMesh, west, south, west + 2 * fillPatchPosts, south + 2 * fillPatchSegments, renderLevel);
 
    createBlock(geometry.ringFixupVerticalMesh, west, south, west + 2 * fillPatchSegments, south + fillPatchSegments, renderLevel);
    createBlock(geometry.ringFixupVerticalMesh, west, south, west + 2 * fillPatchSegments, south + 2 * fillPatchPosts, renderLevel);
 
    createBlock(geometry.centerMesh, west, south, west + 2 * fillPatchSegments, south + 2 * fillPatchSegments, renderLevel);
  } else {
    int offset = terrainLevel.offsetStripOnNorth ? north - fillPatchPosts : south + fillPatchSegments;
 
    createBlock(geometry.offsetStripHorizontalMesh, west, south, west + fillPatchSegments, offset, renderLevel);
 
    int southOffset = terrainLevel.offsetStripOnNorth ? 0 : 1;
    offset = terrainLevel.offsetStripOnEast ? east - fillPatchPosts : west + fillPatchSegments;
 
    createBlock(geometry.offsetStripVerticalMesh, west, south, offset, south + fillPatchSegments + southOffset, renderLevel);
  }
 
  return true;
}
 
bool Cogs::ClipmapRenderer::createBackgroundRenderLevel(ClipmapGeometry & geometry,
                                              ClipmapState & /*clipmapState*/,
                                              ClipmapLevel & terrainLevel,
                                              std::vector<std::vector<ClipmapLevel>> & imagery,
                                              ClipmapLevel * normalLevel,
                                              const GlobalParameters & globalParameters,
                                              const LevelParameters & levelParameters,
                                              const ImageryParameters & imageryParameters,
                                              bool useSimplifiedMesh)
{
  const int west = terrainLevel.currentExtent.west;
  const int south = terrainLevel.currentExtent.south;
 
  RenderLevel & renderLevel = levels[levelIndex++];
 
  renderLevel.globalParameters = &globalParameters;
  renderLevel.levelParameters = &levelParameters;
  renderLevel.imageryParameters = &imageryParameters;
 
  renderLevel.terrainLevel = &terrainLevel;
  renderLevel.coarserTerrainLevel = terrainLevel.coarserLevel;
 
  renderLevel.imagery = &imagery;
 
  renderLevel.normalLevel = normalLevel;
  renderLevel.coarserNormalLevel = normalLevel ? normalLevel->coarserLevel : nullptr;
 
  renderLevel.blockCount = 0;
 
  const int width = terrainLevel.renderTexture.width;
  const int height = terrainLevel.renderTexture.height;
 
  const int blockSize = 64;
 
  const int numDivisionsX = (width + blockSize - 1) / blockSize;
  const int numDivisionsY = (height + blockSize - 1) / blockSize;
 
  const int widthIncrement = blockSize * terrainLevel.currentExtent.getWidth() / terrainLevel.renderTexture.width;
  const int heightIncrement = blockSize * terrainLevel.currentExtent.getHeight() / terrainLevel.renderTexture.height;
 
  if (!HandleIsValid(geometry.worldMesh.vertexBuffer)) {
    geometry.worldMesh = createMesh(geometry.buffers, 0, 0, widthIncrement, heightIncrement, blockSize, blockSize, geometry.meshFormat);
    geometry.simpleWorldMesh = createMesh(geometry.buffers, 0, 0, widthIncrement, heightIncrement, 1, 1, geometry.meshFormat);
  };
 
  for (int x = 0; x < numDivisionsX; ++x) {
    for (int y = 0; y < numDivisionsY; ++y) {
      assert(renderLevel.blockCount < kMaxNumBlocks - 1 && "Number of blocks too large.");
      createBlock(geometry.worldMesh, west, south, west + widthIncrement * x, south + heightIncrement * y, renderLevel, useSimplifiedMesh);
    }
  }
 
  return true;
}
 
void Cogs::ClipmapRenderer::setupDepthPass(RenderContext & renderContext, size_t depthDataIndex)
{
  depthPass = true;
 
  auto context = renderContext.context;
  const auto & permutationRendererData = getPermutationDependentClipmapRendererData(renderContext.permutation);
  auto & variables = permutationRendererData.depthEffectVariables;
 
  auto & depthData = raypickDepthData[depthDataIndex];
 
  context->setRenderTarget(depthData.depthRenderHandle, depthData.depthTargetHandle);
 
  context->setRasterizerState(solidRasterizerState);
  context->setDepthStencilState(solidDepthState);
 
  float color[] = { 1.0f, 0.0f, 0.0f, 1.0f };
  if(reverseDepth) color[0] = 0.0f;
 
  context->clearRenderTarget(color);
  if(reverseDepth)
    context->clearDepth(0.0f);
  else
    context->clearDepth();
  depthData.depthRenderInitialized = true;
 
  context->setViewport(0, 0, static_cast<float>(depthData.width), static_cast<float>(depthData.height));
 
  context->setEffect(permutationRendererData.clipmapDepthEffect);
  context->setInputLayout(inputLayout);
 
  renderContext.callback(permutationRendererData.clipmapDepthEffect);
 
  context->setConstantBuffer(variables.globalBufferBinding, variables.globalBuffer);
  context->setConstantBuffer(variables.levelBufferBinding, variables.levelBuffer);
  context->setConstantBuffer(variables.imageryBufferBinding, variables.imageryBuffer);
  context->setConstantBuffer(variables.patchBufferBinding, variables.patchBuffer);
 
  if (customParameters.size()) {
          auto buffers = renderContext.device->getBuffers();
 
          if (HandleIsValid(customParametersBuffer)) {
                  buffers->releaseBuffer(customParametersBuffer);
          }
 
          customParametersBuffer = buffers->loadBuffer(customParameters.data(), customParameters.size(), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
 
          customParameters.clear();
  }
 
  if (HandleIsValid(customParametersBuffer) && HandleIsValid(variables.customParametersBufferBinding)) {
          context->setConstantBuffer(variables.customParametersBufferBinding, customParametersBuffer);
  }
}
 
void Cogs::ClipmapRenderer::setupDepthQueryPass(RenderContext & renderContext)
{
  depthPass = true;
 
  auto context = renderContext.context;
  const auto & permutationRendererData = getPermutationDependentClipmapRendererData(renderContext.permutation);
  auto & variables = permutationRendererData.depthEffectVariables;
 
  context->setRenderTarget(depthQueryRenderHandle, depthQueryTargetHandle);
 
  context->setRasterizerState(solidNoDepthClipRasterizerState);
  context->setDepthStencilState(solidDepthState);
 
  float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  if(reverseDepth){
    color[0] = 0.0f;
    color[1] = 0.0f;
    color[2] = 0.0f;
  }
 
  context->clearRenderTarget(color);
  if(reverseDepth)
    context->clearDepth(0.0f);
  else
    context->clearDepth();
  depthQueryRenderInitialized = true;
 
  context->setViewport(0, 0, static_cast<float>(depthQuerySize), static_cast<float>(depthQuerySize));
 
  context->setEffect(permutationRendererData.clipmapDepthEffect);
  context->setInputLayout(inputLayout);
 
  renderContext.callback(permutationRendererData.clipmapDepthEffect);
 
  context->setConstantBuffer(variables.globalBufferBinding, variables.globalBuffer);
  context->setConstantBuffer(variables.levelBufferBinding, variables.levelBuffer);
  context->setConstantBuffer(variables.imageryBufferBinding, variables.imageryBuffer);
  context->setConstantBuffer(variables.patchBufferBinding, variables.patchBuffer);
}
 
void Cogs::ClipmapRenderer::setupRegularPass(RenderContext & renderContext)
{
  depthPass = false;
 
  const auto & permutationRendererData = getPermutationDependentClipmapRendererData(renderContext.permutation);
  auto context = renderContext.context;
  auto & variables = permutationRendererData.effectVariables;
 
  context->setRenderTarget(renderContext.renderTarget, renderContext.depthStencilTarget);
  context->setViewport(renderContext.viewportX, renderContext.viewportY, renderContext.width, renderContext.height);
 
  context->setEffect(permutationRendererData.clipmapEffect);
  context->setInputLayout(inputLayout);
 
  renderContext.callback(permutationRendererData.clipmapEffect);
 
  if (renderContext.wireframe) {
    context->setRasterizerState(wireframeRasterizerState);
  } else {
    context->setRasterizerState(renderContext.offsetEnabled ? solidOffsetRasterizerState : solidRasterizerState);
  }
 
  context->setDepthStencilState(renderContext.wireframe ? wireframeDepthState : solidDepthState);
 
  context->setConstantBuffer(variables.globalBufferBinding, variables.globalBuffer);
  context->setConstantBuffer(variables.levelBufferBinding, variables.levelBuffer);
  context->setConstantBuffer(variables.imageryBufferBinding, variables.imageryBuffer);
 
  context->setConstantBuffer(variables.patchBufferBinding, variables.patchBuffer);
 
  if (HandleIsValid(variables.renderBufferBinding)) {
    context->setConstantBuffer(variables.renderBufferBinding, variables.renderBuffer);
  }
 
  if (HandleIsValid(variables.levelRenderBufferBinding)) {
    context->setConstantBuffer(variables.levelRenderBufferBinding, variables.levelRenderBuffer);
  }
 
  if (HandleIsValid(customParametersBuffer) && HandleIsValid(variables.customParametersBufferBinding)) {
    context->setConstantBuffer(variables.customParametersBufferBinding, customParametersBuffer);
  }
}
 
void Cogs::ClipmapRenderer::render(RenderContext & renderContext, const RenderOptions & renderOptions, const WorldOptions & worldOptions, bool usePreviousCullingResults)
{
  if (!usePreviousCullingResults) {
    for (size_t i = 0; i < levelIndex; ++i) {
      const RenderLevel & renderLevel = levels[i];
 
      updateLevelTextures(renderContext.context, &renderLevel, renderContext.permutation);
 
      updateLevelParameters(renderContext.context, renderOptions, *renderLevel.levelParameters, *renderLevel.imageryParameters, renderContext.permutation);
 
      cullRenderBlocks(renderLevel.renderBlocks,
                       visibleBlocks + i * kMaxNumBlocks,
                       renderLevel.blockCount,
                       renderLevel,
                       renderContext.cullVolume,
                       renderContext.center - renderContext.cullOrigin + renderContext.offset,
                       worldOptions.heightExaggeration,
                       static_cast<float>(worldOptions.worldScale.x),
                       static_cast<float>(worldOptions.worldScale.y));
 
      for (size_t j = 0; j < renderLevel.blockCount; ++j) {
        bool draw = visibleBlocks[j + i * kMaxNumBlocks] || !renderOptions.enableCulling;
 
        if (draw) {
          drawBlock(renderLevel.renderBlocks[j], renderContext);
        }
      }
    }
  } else {
    for (size_t i = 0; i < levelIndex; ++i) {
      const RenderLevel & renderLevel = levels[i];
 
      updateLevelTextures(renderContext.context, &renderLevel, renderContext.permutation);
 
      updateLevelParameters(renderContext.context, renderOptions, *renderLevel.levelParameters, *renderLevel.imageryParameters, renderContext.permutation);
 
      for (size_t j = 0; j < renderLevel.blockCount; ++j) {
        if (visibleBlocks[j + i * kMaxNumBlocks] || !renderOptions.enableCulling) {
          drawBlock(renderLevel.renderBlocks[j], renderContext);
        }
      }
    }
  }
}
 
void Cogs::ClipmapRenderer::createBlock(ClipmapMesh & mesh, int overallWest, int overallSouth, int blockWest, int blockSouth, RenderLevel & renderLevel, bool useSimplifiedMesh)
{
  auto & renderBlock = renderLevel.renderBlocks[renderLevel.blockCount++];
 
  renderBlock.mesh = &mesh;
 
  const int textureWest = blockWest - overallWest;
  const int textureSouth = blockSouth - overallSouth;
 
  renderBlock.patchOriginInClippedLevel = Vector2(static_cast<float>(textureWest), static_cast<float>(textureSouth));
 
  // Calculate raster coordinates in terrain coordinate space (pre world scale and origin transform).
  const auto levelOffset = renderLevel.levelParameters->levelOffsetFromClipmapCenter;
  const auto scaleFactor = renderLevel.levelParameters->levelScaleFactor * renderLevel.globalParameters->levelZeroWorldScaleFactor;
 
  renderBlock.min = Vector2(renderBlock.patchOriginInClippedLevel + levelOffset) * scaleFactor;
  renderBlock.max = Vector2(renderBlock.patchOriginInClippedLevel + levelOffset + Vector2(mesh.width, mesh.height)) * scaleFactor;
 
  if (useSimplifiedMesh && renderBlock.mesh == &geometry->fieldBlockMesh) {
    renderBlock.mesh = &geometry->simpleMesh;
  } else if (useSimplifiedMesh && renderBlock.mesh == &geometry->worldMesh) {
    renderBlock.mesh = &geometry->simpleWorldMesh;
  }
}
 
void Cogs::ClipmapRenderer::drawBlock(const RenderBlock & renderBlock, RenderContext & renderContext)
{
  IContext * context = renderContext.context;
 
  auto & permutationRendererData = getPermutationDependentClipmapRendererData(renderContext.permutation);
  const auto & effectVariables = this->depthPass ? permutationRendererData.depthEffectVariables : permutationRendererData.effectVariables;
 
  applyParameters(context, renderBlock.patchOriginInClippedLevel, effectVariables.patchBuffer);
 
  context->setVertexBuffers(&renderBlock.mesh->vertexBuffer, 1, &renderBlock.mesh->stride, nullptr);
  context->setIndexBuffer(renderBlock.mesh->indexBuffer, sizeof(unsigned short), 0);
 
  context->drawIndexed(PrimitiveType::TriangleList, 0, 0);
}
 
void Cogs::ClipmapRenderer::setCustomParameters(const unsigned char * data, int count)
{
  customParameters.assign(data, data + count);
}
 
void Cogs::ClipmapRenderer::cleanup(IGraphicsDevice * device)
{
  if (HandleIsValid(depthQueryRenderHandle)) {
    device->getRenderTargets()->releaseRenderTarget(depthQueryRenderHandle);
  }
 
  if (HandleIsValid(depthQueryTargetHandle)) {
    device->getRenderTargets()->releaseDepthStencilTarget(depthQueryTargetHandle);
  }
 
  if (HandleIsValid(depthQueryTextureHandle)) {
    device->getTextures()->releaseTexture(depthQueryTextureHandle);
  }
 
  for (auto & data : raypickDepthData)
  {
    data.cleanup(device);
  }
}
 
Cogs::RenderTexture Cogs::createClipmapTexture(IGraphicsDevice * device, int width, int height, TextureFormat textureFormat, bool mipmap, glm::vec4 clearColor)
{
  unsigned int flags = TextureFlags::RenderTarget | (mipmap ? TextureFlags::GenerateMipMaps : 0);
  TextureHandle textureHandle = device->getTextures()->loadTexture(nullptr, width, height, textureFormat, flags);
  RenderTargetHandle renderTarget = device->getRenderTargets()->createRenderTarget(textureHandle);
 
  RenderTexture texture = {
    textureHandle,
    Cogs::getTextureSize(width, height, textureFormat),
    width,
    height,
    renderTarget,
    clearColor
  };
 
  assert(HandleIsValid(texture.handle) && "Texture handle not valid.");
  assert(HandleIsValid(texture.renderTarget) && "Render target handle not valid.");
 
  clearClipmapTexture(device, texture);
 
  return texture;
}
 
void Cogs::releaseClipmapTexture(IGraphicsDevice * device, RenderTexture & texture)
{
  if (HandleIsValid(texture.renderTarget)) {
    device->getRenderTargets()->releaseRenderTarget(texture.renderTarget);
  }
 
  device->getTextures()->releaseTexture(texture.handle);
}
 
void Cogs::clearClipmapTexture(IGraphicsDevice * device, RenderTexture & texture)
{
  auto context = device->getImmediateContext();
 
  context->setRenderTarget(texture.renderTarget, DepthStencilHandle::InvalidHandle);
 
  context->clearRenderTarget(reinterpret_cast<float *>(&texture.clearColor));
 
  context->setRenderTarget(RenderTargetHandle::NoHandle, DepthStencilHandle::NoHandle);
}