PostProcessTask.cpp

#include "PostProcessTask.h"
#include "Resources/VertexFormats.h"
 
#include "Context.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Resources/ShaderBuilderPostProcess.h"
 
#include <glm/gtc/type_ptr.hpp>
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  const char * names[] = {
    "linearSampler",
    "linearClampSampler",
    "pointSampler",
    "pointClampSampler",
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("PostProcessTask");
}
 
void Cogs::Core::PostProcessTask::initialize(RenderTaskContext* context)
{
  ProcessTask::initialize(context);
}
 
void Cogs::Core::PostProcessTask::initialize(RenderTaskContext * context, const RenderTaskDefinition& taskDefinition)
{
  ProcessTask::initialize(context, taskDefinition);
 
  EffectDescription desc = createEffectDesc(context);
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
 
  for (auto & p : effectParameter.values) {
    if (p.key == "definitions") {
      for (auto & d : p.values) {
        desc.definitions.push_back({ d.key, d.value });
      }
    }
    else if (p.key == "source") {
      desc.ps = p.value;
    }
    else if (p.key == "useVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "setVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "useComponentFields") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "properties") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "groups" && p.values.size() == 3) {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "options") {
      // Handled in RenderTaskFactory.cpp
    }
    else{
      LOG_WARNING(logger, "Unknown post process task pipeline section \"%s\"", p.key.c_str());
    }
  }
 
  {
    Cogs::GraphicsDeviceType graphicsDeviceType = context->renderer->getDevice()->getType();
    bool success;
    switch (graphicsDeviceType)
    {
    case Cogs::GraphicsDeviceType::OpenGLES30:
      success = Cogs::Core::buildPostProcessEffectES3(context, desc, this);
      break;
    case Cogs::GraphicsDeviceType::WebGPU:
      success = buildPostProcessEffectWebGPU(context, desc, this);
      break;
    default:
      success = buildPostProcessEffect(context, desc, this);
      break;
    }
    if (!success) {
      LOG_ERROR(logger, "Failed to build post processing shader source");
    }
  }
 
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
}
 
Cogs::ResourceStatus Cogs::Core::PostProcessTask::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::Ready && effectStatus != Cogs::ResourceStatus::Ready) {
    IBuffers* buffers = context->device->getBuffers();
    inputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, effect->handle);
    for (size_t i = 0; i < 4; ++i) {
      SamplerStateBindingHandle binding = effects->getSamplerStateBinding(effect->handle, names[i], 0);
      if (HandleIsValid(binding)) {
        samplerStateBindings[i] = binding;
        samplerStates[i] = context->states->commonSamplerStates[i];
      } else {
        samplerStateBindings[i] = SamplerStateBindingHandle::NoHandle;
      }
    }
  }
 
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::PostProcessTask::apply(RenderTaskContext * context)
{
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  if (scopeName.empty()) {
    scopeName = std::string("PostProcessTask<") + name + ">::apply";
  }
 
  DynamicRenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "PostProcessTask", scopeName.c_str());
 
  RenderTarget* renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  if (!renderTarget) {
    return;
  }
 
  auto deviceContext = context->device->getImmediateContext();
  deviceContext->setEffect(effect->handle);
 
  if(context->device->getCapabilities()->getDeviceCapabilities().RenderPass){
    RenderPassInfo info;
    info.renderTargetHandle = renderTarget->renderTargetHandle;
    info.depthStencilHandle = renderTarget->depthTargetHandle;
    {
      uint32_t i = 0;
      info.loadOp[i] = clearColor ? LoadOp::Clear : LoadOp::Load;
      // info.storeOp[i] = writeColor ? StoreOp::Store : StoreOp::Discard;
      info.storeOp[i] = StoreOp::Store; // We can't really do a discard even if we don't write the color cause that may mangle previous writes to the target.
      glm::vec4 color;
      if (clearToDefault) {
        color = context->renderer->getBackgroundColor();
      }
      else{
        color = renderTarget->getClearColor();
      }
      info.clearValue[i][0] = color[0];
      info.clearValue[i][1] = color[1];
      info.clearValue[i][2] = color[2];
      info.clearValue[i][3] = color[3];
    }
    info.depthLoadOp = clearDepth ? LoadOp::Clear : LoadOp::Load;
    info.depthStoreOp = writeDepth ? StoreOp::Store : StoreOp::Discard;
    info.depthClearValue = context->renderer->getClearDepth();
    // info.depthReadOnly = !writeDepth;
    deviceContext->beginRenderPass(info);
  }
  else{
    deviceContext->setRenderTarget(renderTarget->renderTargetHandle, renderTarget->depthTargetHandle);
    if (clearColor) {
      if (clearToDefault) {
        deviceContext->clearRenderTarget(glm::value_ptr(context->renderer->getBackgroundColor()));
      } else {
        deviceContext->clearRenderTarget(glm::value_ptr(renderTarget->getClearColor()));
      }
    }
    if (clearDepth) {
      if (HandleIsValid(renderTarget->depthTargetHandle) || !HandleIsValid(renderTarget->renderTargetHandle)) {
        deviceContext->clearDepth(context->renderer->getClearDepth());
      }
    }
  }
 
  if (viewportFromTarget) {
    deviceContext->setViewport(0.0f, 0.0f, static_cast<float>(renderTarget->width), static_cast<float>(renderTarget->height));
  }
  else {
    // Note: context->cameraData is set when updating engine buffers, so its value is from the last invocation.
    deviceContext->setViewport(
      context->cameraData->viewportOrigin.x, context->cameraData->viewportOrigin.y,
      context->cameraData->viewportSize.x, context->cameraData->viewportSize.y
    );
  }
 
  if (writeDepth && depthTest) {
    deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::leqDepthStencilState]);
  } else if (writeDepth && !depthTest)  {
    deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  }
  else if (!writeDepth && depthTest) {
    deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noWriteDepthStencilState]);
  }
  else {
    deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noDepthStencilState]);
  }
 
  deviceContext->setRasterizerState(context->states->defaultRasterizerStateHandle);
 
  for (size_t i = 0; i < 4; ++i) {
    if (HandleIsValid(samplerStateBindings[i])) {
      deviceContext->setSamplerState(samplerStateBindings[i], samplerStates[i]);
    }
  }
 
  setProperties(context);
 
  if (!writeColor){
    deviceContext->setBlendState(context->states->blendStates[size_t(BlendMode::Zero)].handle);
  }
 
  deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(inputLayout);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
 
  if(context->device->getCapabilities()->getDeviceCapabilities().RenderPass){
    deviceContext->endRenderPass();
  }
}