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/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"
 
using namespace Cogs;
 
bool Cogs::Core::ResolveResourceTask::setupColorEffect(RenderTaskContext * context)
{
  EffectDescription desc;
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "PostProcess/ResolveColor.hlsl";
  colorEffect = context->renderer->getEffectCache().loadEffect(context, desc);
  if(!HandleIsValid(colorEffect->handle)){
    return false;
  }
  IBuffers* buffers = context->device->getBuffers();
  colorInputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, colorEffect->handle);
  IEffects* effects = context->device->getEffects();
  colorTextureBinding = effects->getTextureBinding(colorEffect->handle, "colorTexture", 0);
  return true;
}
bool Cogs::Core::ResolveResourceTask::setupDepthEffect(RenderTaskContext * context)
{
  EffectDescription desc;
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "PostProcess/ResolveDepth.hlsl";
  depthEffect = context->renderer->getEffectCache().loadEffect(context, desc);
  if(!HandleIsValid(depthEffect->handle)){
    return false;
  }
  IBuffers* buffers = context->device->getBuffers();
  depthInputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, depthEffect->handle);
  IEffects* effects = context->device->getEffects();
  depthTextureBinding = effects->getTextureBinding(depthEffect->handle, "depthTexture", 0);
  return true;
}
void Cogs::Core::ResolveResourceTask::resolveColorShader(RenderTaskContext * context,
                                                         RenderTexture * inputTexture,
                                                         RenderTexture * outputTexture)
{
  if(!colorEffect && !setupColorEffect(context)){
    return;
  }
 
  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->noTestDepthStencilStateHandle);
  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)
{
  if(!depthEffect && !setupDepthEffect(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;
  }
 
  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->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(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);
}
 
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::OpenGLES30 &&
     inputTexture->description.flags & TextureFlags::DepthBuffer){
    resolveDepthShader(context, inputTexture, outputTexture);
  }
  else{
    if (inputTexture->description.samples == 1) {
      deviceContext->copyResource(outputTexture->textureHandle, inputTexture->textureHandle);
    } else {
      if(device->getType() == GraphicsDeviceType::WebGPU){
        resolveColorShader(context, inputTexture, outputTexture);
      }
      else{
        deviceContext->resolveResource(inputTexture->textureHandle, outputTexture->textureHandle);
      }
    }
  }
}