ResolveResourceTask.cpp

#include "ResolveResourceTask.h"
 
#include "Rendering/CommandGroupAnnotation.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/ITextures.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderTexture.h"
 
#include "Platform/Instrumentation.h"
 
using namespace Cogs;
 
bool Cogs::Core::ResolveResourceTask::setupEffect(RenderTaskContext * context)
{
  EffectDescription desc;
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "PostProcess/ResolveDepth.hlsl";
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
  if(!HandleIsValid(effect->handle)) return false;
  IEffects* effects = context->device->getEffects();
  depthTextureBinding = effects->getTextureBinding(effect->handle, "depthTexture", 1);
  return true;
}
void Cogs::Core::ResolveResourceTask::resolveDepthShader(RenderTaskContext * context,
                                                         RenderTexture * inputTexture,
                                                         RenderTexture * outputTexture)
{
  if(!effect && !setupEffect(context)){
    return;
  }
 
  IGraphicsDevice* device = context->device;
  IContext* deviceContext = device->getImmediateContext();
 
  CommandGroupAnnotation commandGroup(deviceContext, "ResolveResourceTask::DepthShader");
  if(!outputTexture->resolveTarget){
    RenderTexture* renderTexture = outputTexture;
    RenderTarget* resolveTarget = context->resources->createRenderTarget();
    resolveTarget->setName(outputTexture->getName() + " RT");
    resolveTarget->depth = renderTexture;
    resolveTarget->width = renderTexture->description.width;
    resolveTarget->height = renderTexture->description.height;
    resolveTarget->samples = renderTexture->description.samples;
    resolveTarget->update(context->renderer);
    renderTexture->resolveTarget = resolveTarget;
  }
 
  assert(HandleIsValid(effect->handle));
  deviceContext->setEffect(effect->handle);
 
  RenderTarget* resolveTarget = outputTexture->resolveTarget;
  assert(HandleIsValid(resolveTarget->depthTargetHandle));
  deviceContext->setRenderTarget(RenderTargetHandle::NoHandle, resolveTarget->depthTargetHandle);
  deviceContext->setViewport(0.0f, 0.0f, static_cast<float>(resolveTarget->width), static_cast<float>(resolveTarget->height));
  deviceContext->clearDepth(context->renderer->getClearDepth());
 
  deviceContext->setDepthStencilState(context->states->noTestDepthStencilStateHandle);
  deviceContext->setRasterizerState(context->states->defaultRasterizerStateHandle);
  deviceContext->setBlendState(context->states->blendStates[size_t(BlendMode::Zero)].handle);
 
  deviceContext->setTexture(depthTextureBinding, inputTexture->textureHandle);
 
  deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
}
 
void Cogs::Core::ResolveResourceTask::cleanup(RenderTaskContext * context)
{
  if(effect) context->renderer->getEffectCache().release(context, effect);
}
 
void Cogs::Core::ResolveResourceTask::apply(RenderTaskContext * context)
{
  RenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "ResolveResourceTask::apply");
 
  RenderTexture* inputTexture = input.get(RenderResourceType::RenderTexture)->renderTexure;
  RenderTexture* outputTexture = output.get(RenderResourceType::RenderTexture)->renderTexure;
 
  IGraphicsDevice* device = context->device;
  IContext* deviceContext = device->getImmediateContext();
 
  if (!HandleIsValid(inputTexture->textureHandle)) return;
 
  if(device->getType() == GraphicsDeviceType::Direct3D11 &&
     inputTexture->description.flags & TextureFlags::DepthBuffer){
    resolveDepthShader(context, inputTexture, outputTexture);
  }
  else{
    if (inputTexture->description.samples == 1) {
      deviceContext->copyResource(outputTexture->textureHandle, inputTexture->textureHandle);
    } else {
      deviceContext->resolveResource(inputTexture->textureHandle, outputTexture->textureHandle);
    }
  }
}