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/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
 
#include "Resources/ShaderBuilderPostProcess.h"
 
#include <glm/gtc/type_ptr.hpp>
 
#include "Foundation/Logging/Logger.h"
 
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);
 
  auto effects = context->device->getEffects();
 
  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 });
      }
    }
    if (p.key == "source") {
      desc.ps = p.value;
    }
  }
 
  {
    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);
 
  if (!HandleIsValid(effect->handle)) {
    return;
  }
  auto * buffers = context->device->getBuffers();
  inputLayout = buffers->loadInputLayout(&VertexFormats::Pos4f, 1, effect->handle);
 
  for (size_t i = 0; i < 4; ++i) {
    auto 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;
    }
  }
}
 
void Cogs::Core::PostProcessTask::apply(RenderTaskContext * context)
{
  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;
  }
 
  if (!HandleIsValid(effect->handle)) {
    return;
  }
 
  auto deviceContext = context->device->getImmediateContext();
  deviceContext->setEffect(effect->handle);
  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) {
    deviceContext->setDepthStencilState(context->states->noTestDepthStencilStateHandle);
  } else {
    deviceContext->setDepthStencilState(context->states->noDepthStencilStateHandle);
  }
 
  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);
}