TransparencyMergeTask.cpp

#include "TransparencyMergeTask.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IBuffers.h"
#include "Rendering/IEffects.h"
#include "Rendering/IContext.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderBuffer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderStateUpdater.h"
 
#include "Resources/VertexFormats.h"
 
#include "Context.h"
 
#include "Services/Variables.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
 
#include "DeferredLightingTask.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  struct MergeParameters
  {
    uint32_t alloc;
    uint32_t width;
    uint32_t WidthDivisor;
    uint32_t HeightDivisor;
    float beersScaleFactor;
  };
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TransparencyMergeTask");
}
 
Cogs::ResourceStatus Cogs::Core::TransparencyMergeTask::checkReady(RenderTaskContext * context)
{
  IGraphicsDevice* device = context->renderer->getDevice();
  IBuffers* buffers = device->getBuffers();
 
  EffectDescription desc = {};
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
 
  const char * pixelShaders[] = {
    "Engine/TransparencyBlendAlphaPS.hlsl",
    "Engine/TransparencyBlendMaxPS.hlsl",
    "Engine/TransparencyBlendMax2PS.hlsl",
    "Engine/TransparencyBlendDepthWeightedPS.hlsl",
    "Engine/TransparencyBlendBeersPS.hlsl"
  };
 
  desc.ps = pixelShaders[(int)context->renderer->getSettings().blendKernel];
 
  desc.definitions.push_back({ "COGS_FORWARD_SHADOWS_ENABLED", "1" });
  desc.definitions.push_back({ "COGS_NUM_DIRECTIONAL_SHADOW_LIGHTS", std::to_string(context->renderer->getActiveLights().numDirectionalShadowLights) });
  desc.definitions.push_back({ "COGS_NUM_DIRECTIONAL_LIGHTS", std::to_string(context->renderer->getActiveLights().numDirectionalLights) });
  desc.definitions.push_back({ "COGS_NUM_POINT_SHADOW_LIGHTS", std::to_string(context->renderer->getActiveLights().numPointShadowLights) });
  desc.definitions.push_back({ "COGS_NUM_POINT_LIGHTS", std::to_string(context->renderer->getActiveLights().numPointLights) });
 
  desc.definitions.push_back({ "COGS_DISABLE_DIRECTIONAL_SHADOWS", "1" });
 
  if(context->context->variables->get("renderer.reverseDepth", false)){
    desc.definitions.push_back({ "COGS_REVERSE_DEPTH", "1" });
  }
 
  if (auto ec = context->context->environmentSystem->getGlobalEnvironment(); ec != nullptr) {
    if (ec->subseaSupport) {
      desc.definitions.push_back({ "COGS_SUBSEA_SUPPORT", "1" });
    }
    if (ec->imageBasedLighting) {
      desc.definitions.push_back({ "COGS_IMAGE_BASED_LIGHTING", "1" });
    }
  }
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
 
  IEffects* effects = device->getEffects();
  Cogs::ResourceStatus status = HandleIsValid(effect->handle) ? effects->checkEffect(effect->handle) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Ready && (effectPrev != effect || effectStatus != Cogs::ResourceStatus::Ready)) {
    if (HandleIsValid(parameterHandle)) {
      buffers->releaseBuffer(parameterHandle);
    }
    parameterHandle = device->getBuffers()->loadBuffer(nullptr, sizeof(MergeParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
    buffers->annotate(parameterHandle, "MergeParameters");
    DeferredLightingTask::initializeGlobalBindings(context, effect, bindings);
  }
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid transparency merge effect handle.");
  }
 
  effectPrev = effect;
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::TransparencyMergeTask::cleanup(RenderTaskContext * context)
{
  auto device = context->renderer->getDevice();
  auto buffers = device->getBuffers();
  context->renderer->getEffectCache().release(context, effect);
  if (HandleIsValid(parameterHandle)) {
    buffers->releaseBuffer(parameterHandle);
  }
}
 
void Cogs::Core::TransparencyMergeTask::apply(RenderTaskContext * taskContext)
{
  RenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "TransparencyMergeTask::apply");
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  RenderTarget* deferredRenderTarget = input.get(RenderResourceType::RenderTarget)->renderTarget;
  RenderTarget* renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  RenderBuffer* listTarget = input.get("ListBuffer")->renderBuffer;
  RenderBuffer* nodeTarget = input.get("NodeBuffer")->renderBuffer;
  RenderBuffer* dataTarget = input.get("DataBuffer")->renderBuffer;
 
  IGraphicsDevice* device = taskContext->renderer->getDevice();
  IContext* deviceContext = device->getImmediateContext();
 
  deviceContext->setEffect(effect->handle);
 
  deviceContext->setRenderTarget(renderTarget->renderTargetHandle, renderTarget->depthTargetHandle);
 
  if (clear) {
    deviceContext->clearRenderTarget(glm::value_ptr(renderTarget->getClearColor()));
    deviceContext->clearDepth(taskContext->context->renderer->getClearDepth());
  }
 
  deviceContext->setViewport(0, 0, static_cast<float>(renderTarget->width), static_cast<float>(renderTarget->height));
 
  deviceContext->setDepthStencilState(taskContext->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  deviceContext->setRasterizerState(taskContext->states->defaultRasterizerStateHandle);
 
  if(deferredRenderTarget->textures.size())
    deviceContext->setTexture("colorTexture", 0, deferredRenderTarget->textures[0]->textureHandle);
  deviceContext->setTexture("depthTexture", 1, deferredRenderTarget->depth->textureHandle);
 
  DeferredLightingTask::applyGlobalBindings(taskContext, bindings);
 
  uint32_t widthDivisor = 1;//taskContext->context->variables->get("renderer.oit.UpscaleWidth", 1);
  uint32_t heightDivisor = 1;//taskContext->context->variables->get("renderer.oit.UpscaleHeight", 1);
 
  {
    MappedBuffer<MergeParameters> parameters(deviceContext, parameterHandle, MapMode::WriteDiscard);
 
    if (parameters) {
      parameters->alloc = static_cast<int>(nodeTarget->bufferSize);
      parameters->width = renderTarget->width/widthDivisor;
      parameters->WidthDivisor = widthDivisor;
      parameters->HeightDivisor = heightDivisor;
      parameters->beersScaleFactor = taskContext->renderer->getSettings().beersScaleFactor;
    }
  }
 
  deviceContext->setConstantBuffer("TransparencyParameters", parameterHandle);
 
  deviceContext->setBuffer("List", listTarget->buffer);
  deviceContext->setBuffer("Node", nodeTarget->buffer);
  deviceContext->setBuffer("Data", dataTarget->buffer);
 
  deviceContext->setVertexBuffers(nullptr, 0, nullptr, nullptr);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
}