OceanRenderer.cpp

#include "OceanRenderer.h"
 
#include "ClipmapLevel.h"
#include "ClipmapGeometry.h"
 
#include "RenderBlock.h"
#include "RenderBlockCulling.h"
 
#include "Rendering/IRenderTargets.h"
#include "Rendering/IContext.h"
#include "Rendering/ITextures.h"
#include "Rendering/IEffects.h"
#include "Rendering/CommandGroupAnnotation.h"
 
void Cogs::OceanRenderer::initialize(ClipmapRenderer * renderer, IGraphicsDevice * device)
{
  this->renderer = renderer;
  this->device = device;
 
  Cogs::BlendState blendState = { true, BlendState::Blend::SourceAlpha, BlendState::Blend::InverseSourceAlpha, BlendState::BlendOperation::Add };
  blendStateHandle = device->getRenderTargets()->loadBlendState(blendState);
 
  baseSpectrum.initialize(device);
  timer.start();
}
 
void Cogs::OceanRenderer::initializeTextures(ITextures * /*textures*/, IRenderTargets * /*renderTargets*/)
{
}
 
void Cogs::OceanRenderer::initializeEffects(IBuffers * buffers, IEffects * effects, const size_t numImagery, size_t permutation)
{
  auto & permutationOceanData = getPermutationDependentOceanRendererData(permutation);
  if (!permutationOceanData.initialized) {
    // First time, create and initialize constant buffers.
    initializeConstantBuffers(buffers, permutationOceanData.oceanEffect, permutationOceanData.effectVariables, permutationOceanData.oceanEffectVariables, false);
  }
 
  initializeEffectVariables(effects, permutationOceanData.oceanEffect, permutationOceanData.effectVariables, permutationOceanData.oceanEffectVariables, numImagery, false);
  initializeEffectBindings(effects, permutationOceanData.oceanEffect, permutationOceanData.oceanEffectBindings, numImagery, false);
 
  VertexElement element = { 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 };
  VertexFormatHandle meshFormat = device->getBuffers()->createVertexFormat(&element, 1);
  inputLayout = buffers->loadInputLayout(&meshFormat, 1, permutationOceanData.oceanEffect);
 
  permutationOceanData.initialized = true;
}
 
void Cogs::OceanRenderer::initializeConstantBuffers(IBuffers * buffers, EffectHandle /*effect*/, ClipmapEffectVariables & variables, OceanEffectVariables & oceanEffectVariables, bool /*isDepth*/)
{
  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);
 
  oceanEffectVariables.oceanBuffer = buffers->loadBuffer(nullptr, sizeof(OceanParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
}
 
void Cogs::OceanRenderer::initializeEffectVariables(IEffects * effects, EffectHandle effectHandle, ClipmapEffectVariables & variables, OceanEffectVariables & oceanEffectVariables, const size_t /*numImagery*/, bool isDepth)
{
  variables.globalBufferBinding= effects->getConstantBufferBinding(effectHandle, "GlobalParameters");
  variables.levelBufferBinding = effects->getConstantBufferBinding(effectHandle, "LevelParameters");
 
  variables.patchBufferBinding = effects->getConstantBufferBinding(effectHandle, "PatchParameters");
 
  if (!isDepth) {
    variables.imageryBufferBinding = effects->getConstantBufferBinding(effectHandle, "ImageryParameters");
 
    variables.renderBufferBinding = effects->getConstantBufferBinding(effectHandle, "RenderParameters");
    variables.levelRenderBufferBinding = effects->getConstantBufferBinding(effectHandle, "LevelRenderParameters");
  }
 
  variables.customParametersBufferBinding = effects->getConstantBufferBinding(effectHandle, "CustomParameters");
 
  oceanEffectVariables.oceanBufferBinding = effects->getConstantBufferBinding(effectHandle, "OceanParameters");
}
 
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::OceanRenderer::initializeEffectBindings(IEffects * effects, EffectHandle effect, ClipmapTextureBindings & bindings, const size_t numImagery, bool isDepth)
{
  int unit = 5;
 
  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) {
    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 (oceanOptions.enableImagery) {
      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;
      }
    }
  }
}
 
namespace Cogs
{
  template<typename Parameters>
  void applyParameters(IContext * context, const Parameters & parameters, BufferHandle bufferHandle)
  {
    Parameters * out = static_cast<Parameters *>(context->map(bufferHandle, MapMode::WriteDiscard));
 
    ::memcpy(out, &parameters, sizeof(Parameters));
 
    context->unmap(bufferHandle);
  }
}
 
void Cogs::OceanRenderer::updateGlobalParameters(const RenderContext & renderContext, const RenderOptions & renderOptions, const ClipmapState & /*clipmapState*/, const GlobalParameters & globalParameters)
{
  IContext * context = renderContext.context;
  auto & permutationOceanData = getPermutationDependentOceanRendererData(renderContext.permutation);
 
  const auto & variables = permutationOceanData.effectVariables;
 
  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);
 
  double baseTileCoordsFromWorld = 1.0 / static_cast<double>(oceanOptions.worldSpaceMeter*baseSpectrum.getTileExtent());
  double baseTileX = baseTileCoordsFromWorld*renderContext.origin[0];
  double baseTileY = baseTileCoordsFromWorld*renderContext.origin[1];
 
  double detailTileCoordsFromWorld = 17.0 / static_cast<double>(oceanOptions.worldSpaceMeter*baseSpectrum.getTileExtent());
  double detailTileX = detailTileCoordsFromWorld*renderContext.origin[0];
  double detailTileY = detailTileCoordsFromWorld*renderContext.origin[1];
 
  oceanParameters.viewportScale.x = 2.f*renderContext.width;
  oceanParameters.viewportScale.y = 2.f*renderContext.height;
 
  oceanParameters.tileCoordsFromWorld.x = static_cast<float>(baseTileCoordsFromWorld);
  oceanParameters.tileCoordsFromWorld.y = static_cast<float>(detailTileCoordsFromWorld);
 
  oceanParameters.tileOffset.x = static_cast<int>(std::floor(baseTileX));
  oceanParameters.tileOffset.y = static_cast<int>(std::floor(baseTileY));
  oceanParameters.tileOffset.z = static_cast<int>(std::floor(detailTileX));
  oceanParameters.tileOffset.w = static_cast<int>(std::floor(detailTileY));
 
  oceanParameters.tileRemainder.x = static_cast<float>(baseTileX - std::floor(baseTileX));
  oceanParameters.tileRemainder.y = static_cast<float>(baseTileY - std::floor(baseTileY));
  oceanParameters.tileRemainder.z = static_cast<float>(detailTileX - std::floor(detailTileX));
  oceanParameters.tileRemainder.w = static_cast<float>(detailTileY - std::floor(detailTileY));
 
  oceanParameters.oneOverTileExtentAdjust = 1.f / baseSpectrum.getTileExtentAdjust();
 
//  oceanParameters.baseTileCoordsFromWorld = 1.f / (oceanOptions.worldSpaceMeter*oceanOptions.baseTileLength);
//  oceanParameters.significantWaveHeightWorld = oceanOptions.worldSpaceMeter * oceanOptions.significantWaveHeight;
// oceanParameters.oceanOrigin = vec4(std::fmod(renderContext.origin[0], 1000.0f), std::fmod(renderContext.origin[1], 1000.0f), 0, 0);
 
  applyParameters(context, oceanParameters, permutationOceanData.oceanEffectVariables.oceanBuffer);
}
 
void Cogs::OceanRenderer::updateLevelParameters(IContext * context, const RenderOptions & options, const LevelParameters & parameters, const ImageryParameters & imageryParameters, size_t permutation)
{
  auto & permutationOceanData = getPermutationDependentOceanRendererData(permutation);
  const auto & variables = permutationOceanData.effectVariables;
 
  applyParameters(context, parameters, variables.levelBuffer);
  applyParameters(context, imageryParameters, variables.imageryBuffer);
 
  applyParameters(context, options.diffuseColor, variables.levelRenderBuffer);
}
 
void Cogs::OceanRenderer::updateLevelTextures(IContext * context, const RenderLevel * renderLevel, size_t permutation)
{
  auto & permutationOceanData = getPermutationDependentOceanRendererData(permutation);
  auto & bindings = permutationOceanData.oceanEffectBindings;
 
  context->setTexture(bindings.heightMapBinding, renderLevel->terrainLevel->renderTexture.handle);
  context->setSamplerState(bindings.heightMapSamplerBinding, renderer->pointSamplerState);
 
  context->setTexture(bindings.coarseHeightMapBinding, renderLevel->coarserTerrainLevel->renderTexture.handle);
  context->setSamplerState(bindings.coarseHeightMapSamplerBinding, renderer->linearSamplerState);
 
  if (renderLevel->normalLevel) {
    context->setTexture(bindings.normalMapBinding, renderLevel->normalLevel->renderTexture.handle);
    context->setSamplerState(bindings.normalMapSamplerBinding, renderer->linearSamplerState);
 
    context->setTexture(bindings.coarseNormalMapBinding, renderLevel->coarserNormalLevel->renderTexture.handle);
    context->setSamplerState(bindings.coarseNormalMapSamplerBinding, renderer->linearSamplerState);
  }
 
  const size_t levelIndex = renderLevel->terrainLevel->index;
 
  if (oceanOptions.enableImagery) {
    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, renderer->linearSamplerState);
 
      context->setTexture(perImageBindings.coarseImageryBinding, imageryLevel.coarserLevel->renderTexture.handle);
      context->setSamplerState(perImageBindings.coarseImagerySamplerBinding, renderer->linearSamplerState);
    }
  }
}
 
void Cogs::OceanRenderer::preRender(RenderContext & renderContext)
{
  CommandGroupAnnotation preGroup(renderContext.context, "Ocean::preRender");
 
 
  if ((baseTileSizeLog2 != oceanOptions.baseTileSizeLog2) ||
      (baseTileLength != oceanOptions.baseTileLength) ||
      (significantWavePeriod != oceanOptions.significantWavePeriod))
  {
 
    if (baseTileSizeLog2 != oceanOptions.baseTileSizeLog2) {
      baseTileSizeLog2 = oceanOptions.baseTileSizeLog2;
      baseSpectrum.setSize(baseTileSizeLog2);
    }
 
    baseTileLength = oceanOptions.baseTileLength;
    significantWavePeriod = oceanOptions.significantWavePeriod;
 
    baseSpectrum.setConditions(baseTileLength,
                               0.f, 0.f,
                               significantWavePeriod,
                               10.f, 0.f,
                               0.f, 42);
  }
 
  float dt = static_cast<float>(timer.elapsedSeconds());
  timer.start();
 
  baseSpectrum.update(renderContext, dt);
}
 
void Cogs::OceanRenderer::setupOceanPass(RenderContext & renderContext)
{
  auto context = renderContext.context;
  auto & permutationOceanData = getPermutationDependentOceanRendererData(renderContext.permutation);
  auto & variables = permutationOceanData.effectVariables;
 
  context->setEffect(permutationOceanData.oceanEffect);
  context->setInputLayout(inputLayout);
 
  renderContext.oceanCallback(permutationOceanData.oceanEffect);
  
  context->setTexture("wavePosition", 0, baseSpectrum.positionTex());
  context->setSamplerState("wavePositionSampler", 0, renderer->linearSamplerState);
 
  context->setTexture("waveDerivatives", 1, baseSpectrum.derivativesTex());
  context->setSamplerState("waveDerivativesSampler", 1, renderer->linearSamplerState);
 
  if (renderContext.wireframe) {
    context->setRasterizerState(renderer->wireframeRasterizerState);
  } else {
    context->setRasterizerState(renderContext.offsetEnabled ? renderer->solidOffsetRasterizerState : renderer->solidRasterizerState);
  }
 
  if (!renderContext.isOIT) {
    context->setBlendState(blendStateHandle);
 
    context->setDepthStencilState(renderContext.wireframe ? renderer->transparentWireframeDepthState : renderer->transparentDepthState);
  }
 
  context->setConstantBuffer(variables.globalBufferBinding, variables.globalBuffer);
  context->setConstantBuffer(variables.levelBufferBinding, variables.levelBuffer);
  
  if (HandleIsValid(variables.imageryBufferBinding)) {
    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(permutationOceanData.oceanEffectVariables.oceanBufferBinding)) {
    context->setConstantBuffer(permutationOceanData.oceanEffectVariables.oceanBufferBinding, permutationOceanData.oceanEffectVariables.oceanBuffer);
  }
 
  if (HandleIsValid(renderer->customParametersBuffer) && HandleIsValid(variables.customParametersBufferBinding)) {
          context->setConstantBuffer(variables.customParametersBufferBinding, renderer->customParametersBuffer);
  }
}
 
void Cogs::OceanRenderer::render(RenderContext & renderContext, const RenderOptions & renderOptions, const WorldOptions & worldOptions, bool usePreviousCullingResults)
{
  if (!usePreviousCullingResults) {
    for (size_t i = 0; i < renderer->levelIndex; ++i) {
      const RenderLevel & renderLevel = renderer->levels[i];
 
      updateLevelTextures(renderContext.context, &renderLevel, renderContext.permutation);
 
      updateLevelParameters(renderContext.context, renderOptions, *renderLevel.levelParameters, *renderLevel.imageryParameters, renderContext.permutation);
 
      cullRenderBlocks(renderLevel.renderBlocks,
                       renderer->visibleBlocks + i * kMaxNumBlocks,
                       renderLevel.blockCount,
                       renderLevel,
                       renderContext.cullVolume,
                       renderContext.center - renderContext.cullOrigin,
                       0.0f,
                       static_cast<float>(worldOptions.worldScale.x),
                       static_cast<float>(worldOptions.worldScale.y));
 
      for (size_t j = 0; j < renderLevel.blockCount; ++j) {
        if (renderer->visibleBlocks[j + i * kMaxNumBlocks] || !renderOptions.enableCulling) {
          drawBlock(renderLevel.renderBlocks[j], renderContext);
        }
      }
    }
  } else {
    for (size_t i = 0; i < renderer->levelIndex; ++i) {
      const RenderLevel & renderLevel = renderer->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 (renderer->visibleBlocks[j + i * kMaxNumBlocks] || !renderOptions.enableCulling) {
          drawBlock(renderLevel.renderBlocks[j], renderContext);
        }
      }
    }
  }
}
 
void Cogs::OceanRenderer::drawBlock(const RenderBlock & renderBlock, RenderContext & renderContext)
{
  IContext * context = renderContext.context;
 
  auto & permutationOceanData = getPermutationDependentOceanRendererData(renderContext.permutation);
  applyParameters(context, renderBlock.patchOriginInClippedLevel, permutationOceanData.effectVariables.patchBuffer);
 
  context->setVertexBuffers(&renderBlock.mesh->vertexBuffer, 1, &renderBlock.mesh->stride, nullptr);
  context->setIndexBuffer(renderBlock.mesh->indexBuffer, 2, 0);
 
  context->drawIndexed(PrimitiveType::TriangleList, 0, 0);
}
 
void Cogs::OceanRenderer::setOptions(const OceanOptions * options)
{
  oceanOptions = *options;
}
 
void Cogs::OceanRenderer::update()
{
  float significantWaveLength = (9.81f*oceanOptions.significantWavePeriod*oceanOptions.significantWavePeriod) / (2.f*glm::pi<float>());
 
  oceanParameters.deepColor = oceanOptions.deepColor;
  oceanParameters.shallowColor = oceanOptions.shallowColor;
  oceanParameters.roughColor = oceanOptions.roughColor;
 
  oceanParameters.foamDetectionScale = -oceanOptions.foamDetectionScale*significantWaveLength;
  oceanParameters.significantWaveHeightWorld = oceanOptions.worldSpaceMeter * oceanOptions.significantWaveHeight;
  oceanParameters.worldSpaceMeter = oceanOptions.worldSpaceMeter;
  oceanParameters.shoale = oceanOptions.shoale;
  oceanParameters.swellDirection = oceanOptions.swellDirection;
  oceanParameters.roughness = oceanOptions.roughness;
 
  oceanParameters.foamErosionValue = oceanOptions.foamErosionValue;
  oceanParameters.shoalingEffectFactor = oceanOptions.shoalingEffectFactor;
 
  oceanParameters.lodDisplace.x = oceanOptions.lodDisplaceStart;
  oceanParameters.lodDisplace.y = oceanOptions.lodDisplaceTransition;
  oceanParameters.lodNormal.x = oceanOptions.lodNormalStart;
  oceanParameters.lodNormal.y = oceanOptions.lodNormalTransition;
  oceanParameters.lodDetail.x = oceanOptions.lodDetailStart;
  oceanParameters.lodDetail.y = oceanOptions.lodDetailTransition;
  oceanParameters.lodFoam.x = oceanOptions.lodFoamStart;
  oceanParameters.lodFoam.y = oceanOptions.lodFoamTransition;
}