PostProcessTask.cpp

#include "PostProcessTask.h"
#include "Resources/VertexFormats.h"
 
#include "Context.h"
#include "Renderer/IRenderer.h"
#include "Renderer/RenderTarget.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
 
#include <glm/gtc/type_ptr.hpp>
 
using namespace Cogs;
 
namespace
{
  const char * names[] = {
    "linearSampler",
    "linearClampSampler",
    "pointSampler",
    "pointClampSampler",
  };
}
 
void Cogs::Core::PostProcessTask::initialize(RenderTaskContext * context)
{
  ProcessTask::initialize(context);
 
  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;
    }
  }
 
  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 (clear) {
    if (clearToDefault) {
      deviceContext->clearRenderTarget(glm::value_ptr(context->renderer->getBackgroundColor()));
    } else {
      deviceContext->clearRenderTarget(glm::value_ptr(renderTarget->getClearColor()));
    }
 
    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);
  deviceContext->setBlendState(context->states->blendStates[size_t(BlendMode::None)].handle);
 
  for (size_t i = 0; i < 4; ++i) {
    if (HandleIsValid(samplerStateBindings[i])) {
      deviceContext->setSamplerState(samplerStateBindings[i], samplerStates[i]);
    }
  }
 
  setProperties(context);
 
  deviceContext->setVertexBuffers(&context->states->fullScreenTriangle, 1);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(inputLayout);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
}