ResolveResourceTask.cpp

#include "ResolveResourceTask.h"
 
#include "ProcessTask.h"
 
#include "Rendering/CommandGroupAnnotation.h"
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
 
#include "Resources/VertexFormats.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderTexture.h"
 
#include "Platform/Instrumentation.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ResolveResourceTask");
}
 
Cogs::ResourceStatus Cogs::Core::ResolveResourceTask::setupColorEffect(RenderTaskContext * context)
{
  if (!colorEffect) {
    EffectDescription desc;
    desc.vs = "Engine/FullscreenV3T2VS.hlsl";
    desc.ps = "PostProcess/ResolveColor.hlsl";
    colorEffect = context->renderer->getEffectCache().loadEffect(context, desc);
  }
 
  IEffects* effects = context->device->getEffects();
  Cogs::ResourceStatus status = HandleIsValid(colorEffect->handle) ? effects->checkEffect(colorEffect->handle) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Ready && colorEffectStatus != Cogs::ResourceStatus::Ready) {
    IBuffers* buffers = context->device->getBuffers();
    colorInputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, colorEffect->handle);
    colorTextureBinding = effects->getTextureBinding(colorEffect->handle, "colorTexture", 0);
  }
 
  if (status == Cogs::ResourceStatus::Error && colorEffectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid resolve color effect handle.");
  }
 
  colorEffectStatus = status;
  return colorEffectStatus;
}
Cogs::ResourceStatus Cogs::Core::ResolveResourceTask::setupDepthEffect(RenderTaskContext * context)
{
  if (!depthEffect) {
    EffectDescription desc;
    desc.vs = "Engine/FullscreenV3T2VS.hlsl";
    desc.ps = "PostProcess/ResolveDepth.hlsl";
    depthEffect = context->renderer->getEffectCache().loadEffect(context, desc);
  }
 
  IEffects* effects = context->device->getEffects();
  Cogs::ResourceStatus status = HandleIsValid(depthEffect->handle) ? effects->checkEffect(depthEffect->handle) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Ready && depthEffectStatus != Cogs::ResourceStatus::Ready) {
    IBuffers* buffers = context->device->getBuffers();
    depthInputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, depthEffect->handle);
    depthTextureBinding = effects->getTextureBinding(depthEffect->handle, "depthTexture", 0);
  }
 
  if (status == Cogs::ResourceStatus::Error && depthEffectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid resolve depth effect handle.");
  }
 
  depthEffectStatus = status;
  return depthEffectStatus;
}
void Cogs::Core::ResolveResourceTask::resolveColorShader(RenderTaskContext * context,
                                                         RenderTexture * inputTexture,
                                                         RenderTexture * outputTexture)
{
  assert(colorEffectStatus == Cogs::ResourceStatus::Ready);
 
  IGraphicsDevice* device = context->device;
  IContext* deviceContext = device->getImmediateContext();
 
  CommandGroupAnnotation commandGroup(deviceContext, "ResolveResourceTask::ColorShader");
  if(!outputTexture->resolveTarget){
    RenderTexture* renderTexture = outputTexture;
    RenderTarget* resolveTarget = context->resources->createRenderTarget();
    resolveTarget->setName(outputTexture->getName() + " RT");
    resolveTarget->textures.push_back(renderTexture);
    resolveTarget->width = renderTexture->description.width;
    resolveTarget->height = renderTexture->description.height;
    resolveTarget->samples = renderTexture->description.samples;
    resolveTarget->update(context->renderer);
    renderTexture->resolveTarget = resolveTarget;
  }
 
  deviceContext->setEffect(colorEffect->handle);
 
  RenderTarget* resolveTarget = outputTexture->resolveTarget;
  assert(HandleIsValid(resolveTarget->renderTargetHandle));
  if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
    RenderPassInfo info = RenderPassInfo();
    info.renderTargetHandle = resolveTarget->renderTargetHandle;
    info.depthStencilHandle = DepthStencilHandle::NoHandle;
    info.loadOp[0] = LoadOp::Clear;
    info.storeOp[0] = StoreOp::Store;
    info.depthLoadOp = LoadOp::Undefined;
    info.depthStoreOp = StoreOp::Undefined;
    info.depthClearValue = context->renderer->getClearDepth();
    info.depthReadOnly = true;
    deviceContext->beginRenderPass(info);
  }
  else{
    deviceContext->setRenderTarget(resolveTarget->renderTargetHandle, DepthStencilHandle::NoHandle);
    float vals[4] = {};
    deviceContext->clearRenderTarget(vals);
  }
 
  deviceContext->setViewport(0.0f, 0.0f, static_cast<float>(resolveTarget->width), static_cast<float>(resolveTarget->height));
 
  deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  deviceContext->setRasterizerState(context->states->defaultRasterizerStateHandle);
  deviceContext->setBlendState(context->states->blendStates[size_t(BlendMode::None)].handle);
 
  deviceContext->setTexture(colorTextureBinding, inputTexture->textureHandle);
 
  deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(colorInputLayout);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
 
  if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
    deviceContext->endRenderPass();
  }
}
void Cogs::Core::ResolveResourceTask::resolveDepthShader(RenderTaskContext * context,
                                                         RenderTexture * inputTexture,
                                                         RenderTexture * outputTexture)
{
  assert(depthEffectStatus == Cogs::ResourceStatus::Ready);
 
  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;
  }
 
  deviceContext->setEffect(depthEffect->handle);
 
  RenderTarget* resolveTarget = outputTexture->resolveTarget;
  assert(HandleIsValid(resolveTarget->depthTargetHandle));
  if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
    RenderPassInfo info = RenderPassInfo();
    info.renderTargetHandle = RenderTargetHandle::NoHandle;
    info.depthStencilHandle = resolveTarget->depthTargetHandle;
    info.depthLoadOp = LoadOp::Clear;
    info.depthStoreOp = StoreOp::Store;
    info.depthClearValue = context->renderer->getClearDepth();
    info.depthReadOnly = false;
    deviceContext->beginRenderPass(info);
  }
  else{
    deviceContext->setRenderTarget(RenderTargetHandle::NoHandle, resolveTarget->depthTargetHandle);
    deviceContext->clearDepth(context->renderer->getClearDepth());
  }
 
  deviceContext->setViewport(0.0f, 0.0f, static_cast<float>(resolveTarget->width), static_cast<float>(resolveTarget->height));
 
  deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  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(depthInputLayout);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
 
  if (device->getCapabilities()->getDeviceCapabilities().RenderPass) {
    deviceContext->endRenderPass();
  }
}
 
void Cogs::Core::ResolveResourceTask::cleanup(RenderTaskContext * context)
{
  if(colorEffect) context->renderer->getEffectCache().release(context, colorEffect);
  if(depthEffect) context->renderer->getEffectCache().release(context, depthEffect);
}
 
Cogs::ResourceStatus Cogs::Core::ResolveResourceTask::checkReady(RenderTaskContext * context)
{
  RenderTexture* inputTexture = input.get(RenderResourceType::RenderTexture)->renderTexure;
  IGraphicsDevice* device = context->device;
 
  if (!HandleIsValid(inputTexture->textureHandle)) {
    action = ResolveAction::None;
    return Cogs::ResourceStatus::Ready;
  }
 
  if (device->getType() != GraphicsDeviceType::OpenGLES30 &&
      inputTexture->description.flags & TextureFlags::DepthBuffer) {
    action = ResolveAction::DepthShader;
    return setupDepthEffect(context);
  }
 
  if (inputTexture->description.samples == 1) {
    action = ResolveAction::Copy;
    return Cogs::ResourceStatus::Ready;
  }
 
  if (device->getType() == GraphicsDeviceType::WebGPU) {
    action = ResolveAction::ColorShader;
    return setupColorEffect(context);
  }
 
  action = ResolveAction::Resolve;
  return Cogs::ResourceStatus::Ready;
}
 
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;
 
  IContext* deviceContext = context->device->getImmediateContext();
 
  switch (action) {
  case ResolveAction::None:
    break;
  case ResolveAction::Copy:
    deviceContext->copyResource(outputTexture->textureHandle, inputTexture->textureHandle);
    break;
  case ResolveAction::Resolve:
    deviceContext->resolveResource(inputTexture->textureHandle, outputTexture->textureHandle);
    break;
  case ResolveAction::ColorShader:
    resolveColorShader(context, inputTexture, outputTexture);
    break;
  case ResolveAction::DepthShader:
    resolveDepthShader(context, inputTexture, outputTexture);
    break;
  }
}