TransparencyUpscaleTask.cpp

#include "TransparencyUpscaleTask.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 "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  struct UpscaleParameters
  {
    uint32_t width, height;
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TransparencyUpscaleTask");
}
 
void Cogs::Core::TransparencyUpscaleTask::initialize(RenderTaskContext * context)
{
  IGraphicsDevice* device = context->renderer->getDevice();
  IBuffers* buffers = device->getBuffers();
 
  EffectDescription desc = {};
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "Engine/TransparencyUpscalePS.hlsl";
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
 
  parameterHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(UpscaleParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
  buffers->annotate(parameterHandle, "UpscaleParameters");
}
 
void Cogs::Core::TransparencyUpscaleTask::cleanup(RenderTaskContext * context)
{
  auto device = context->renderer->getDevice();
  auto buffers = device->getBuffers();
  context->renderer->getEffectCache().release(context, effect);
  buffers->releaseBuffer(parameterHandle);
}
 
Cogs::ResourceStatus Cogs::Core::TransparencyUpscaleTask::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 upscale effect handle.");
  }
 
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::TransparencyUpscaleTask::apply(RenderTaskContext * taskContext)
{
  RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "TransparencyUpscaleTask::apply");
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  uint32_t frame = taskContext->context->time->getFrame();
 
  RenderTexture *color = (frame%2==0) ? input.resources[0].renderTexure : input.resources[1].renderTexure;
  auto deferredRenderTarget = input.get(RenderResourceType::RenderTarget)->renderTarget;
  auto renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  auto device = taskContext->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  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("oitTexture", 0, color->textureHandle);
  deviceContext->setTexture("colorTexture", 0, deferredRenderTarget->textures[0]->textureHandle);
  deviceContext->setTexture("depthTexture", 1, deferredRenderTarget->depth->textureHandle);
 
  {
    MappedBuffer<UpscaleParameters> parameters(deviceContext, parameterHandle, MapMode::WriteDiscard);
 
    if (parameters) {
      parameters->width = taskContext->context->variables->get("renderer.oit.UpscaleWidth", 1);
      parameters->height = taskContext->context->variables->get("renderer.oit.UpscaleHeight", 1);
    }
  }
 
  deviceContext->setConstantBuffer("UpscaleParameters", parameterHandle);
 
  deviceContext->setVertexBuffers(nullptr, 0, nullptr, nullptr);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
}