TransparencyTemporalUpscaleTask.cpp

#include "TransparencyTemporalUpscaleTask.h"
 
#include "Context.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderStateUpdater.h"
#include "Services/Time.h"
#include "Services/Variables.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/IEffects.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  struct TemporalParameters
  {
    glm::mat4 inverseClipToWorldMatrix;
    glm::mat4 prevWorldToClipMatrix;
    uint32_t width;
    uint32_t height;
    uint32_t off_x;
    uint32_t off_y;
    uint32_t size_x;
    uint32_t size_y;
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TransparencyTemporalUpscaleTask");
}
 
void Cogs::Core::TransparencyTemporalUpscaleTask::initialize(RenderTaskContext * context)
{
  IGraphicsDevice* device = context->renderer->getDevice();
  IBuffers* buffers = device->getBuffers();
  ITextures* textures = device->getTextures();
 
  EffectDescription desc = {};
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "Engine/TransparencyTemporalUpscalePS.hlsl";
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
 
  parameterHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(TemporalParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  buffers->annotate(parameterHandle, "TemporalParameters");
 
  SamplerState samplerState{};
  samplerState.addressModeS = SamplerState::Clamp;
  samplerState.addressModeT = SamplerState::Clamp;
  samplerState.addressModeW = SamplerState::Clamp;
  samplerState.filter = SamplerState::MinMagMipLinear;
  for (unsigned i = 0; i < 4; i++)
    samplerState.borderColor[i] = 0.f;
  sampler = textures->loadSamplerState(samplerState);
}
 
void Cogs::Core::TransparencyTemporalUpscaleTask::cleanup(RenderTaskContext * context)
{
  auto device = context->renderer->getDevice();
  auto buffers = device->getBuffers();
  auto textures = device->getTextures();
  context->renderer->getEffectCache().release(context, effect);
  buffers->releaseBuffer(parameterHandle);
  textures->releaseSamplerState(sampler);
}
 
Cogs::ResourceStatus Cogs::Core::TransparencyTemporalUpscaleTask::checkReady(RenderTaskContext * context)
{
  IEffects* effects = context->device->getEffects();
 
  Cogs::ResourceStatus status = HandleIsValid(effect->handle) ? effects->checkEffect(effect->handle) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid transparency temporal upscale effect handle.");
  }
 
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::TransparencyTemporalUpscaleTask::apply(RenderTaskContext * taskContext)
{
  RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "TransparencyTemporalUpscaleTask::apply");
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  uint32_t frame = taskContext->context->time->getFrame();
  uint32_t widthDivisor = taskContext->context->variables->get("renderer.oit.TemporalUpscaleWidth", 1);
  uint32_t heightDivisor = taskContext->context->variables->get("renderer.oit.TemporalUpscaleHeight", 1);
 
  auto device = taskContext->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  auto depthTarget = input.resources[0].renderTarget;
  auto oitTarget = input.resources[1].renderTarget;
  auto historyTarget = input.resources[(frame+1)%2+2].renderTarget;
  auto renderTarget = output.resources[frame%2].renderTarget;
 
  deviceContext->setEffect(effect->handle);
 
  deviceContext->setRenderTarget(renderTarget->renderTargetHandle, renderTarget->depthTargetHandle);
  deviceContext->setViewport(0, 0, static_cast<float>(renderTarget->width), static_cast<float>(renderTarget->height));
 
  deviceContext->setDepthStencilState(taskContext->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  deviceContext->setRasterizerState(taskContext->states->defaultRasterizerStateHandle);
 
  deviceContext->setTexture("depthTexture", 0, depthTarget->depth->textureHandle);
  deviceContext->setTexture("oitTexture", 0, oitTarget->textures[0]->textureHandle);
  deviceContext->setTexture("historyTexture", 0, historyTarget->textures[0]->textureHandle);
  deviceContext->setSamplerState("historySampler", 0, sampler);
 
  {
    MappedBuffer<TemporalParameters> parameters(deviceContext, parameterHandle, MapMode::WriteDiscard);
 
    if (parameters) {
      auto&    cameraData = taskContext->context->cameraSystem->getMainCameraData();
      uint32_t i = frame % (widthDivisor * heightDivisor);
 
      parameters->inverseClipToWorldMatrix = cameraData.inverseViewProjectionMatrix;
      parameters->prevWorldToClipMatrix = cameraData.prevViewProjection;
      parameters->width = widthDivisor;
      parameters->height = heightDivisor;
      parameters->off_x = i % widthDivisor;
      parameters->off_y = (i / widthDivisor) % heightDivisor;
      parameters->size_x = historyTarget->width;
      parameters->size_y = historyTarget->height;
    }
  }
  deviceContext->setConstantBuffer("TemporalParameters", parameterHandle);
 
  deviceContext->setVertexBuffers(nullptr, 0, nullptr, nullptr);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
}