DeferredLightingTask.cpp

#include "DeferredLightingTask.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/CommandGroupAnnotation.h"
 
#include "Context.h"
#include "Renderer/Renderer.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderStateUpdater.h"
#include "Services/Variables.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
#include "Utilities/Parsing.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DeferredLightingTask");
}
 
Cogs::ResourceStatus Cogs::Core::DeferredLightingTask::checkReady(RenderTaskContext * context)
{
  IGraphicsDevice* device = context->renderer->getDevice();
  IContext* deviceContext = device->getImmediateContext();
  CommandGroupAnnotation annotation(deviceContext, "DeferredLightingTask::initialize");
 
  EffectDescription desc;
  desc.vs = "Engine/FullscreenV3T2VS.hlsl";
  desc.ps = "Engine/DeferredLightingPS.hlsl";
  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) });
 
  auto softShadows = parseEnum<SoftShadows>(context->context->variables->get("shadows.softShadows", "Default"));
  switch (softShadows) {
  case SoftShadows::High:
    desc.definitions.push_back({ "COGS_SOFT_SHADOWS_HIGH", "1" });
    break;
  case SoftShadows::Low:
    desc.definitions.push_back({ "COGS_SOFT_SHADOWS_LOW", "1" });
    break;
  default:
    break;
  }
  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" });
    }
  }
  if(context->context->variables->get("renderer.reverseDepth", false)){
    desc.definitions.push_back({ "COGS_REVERSE_DEPTH", "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)) {
    initializeGlobalBindings(context, effect, bindings);
  }
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid deferred lighting effect handle.");
  }
 
  effectPrev = effect;
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::DeferredLightingTask::cleanup(RenderTaskContext * context)
{
  context->renderer->getEffectCache().release(context, effect);
}
 
void Cogs::Core::DeferredLightingTask::apply(RenderTaskContext * context)
{
  RenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "DeferredLightingTask::apply");
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  RenderTarget* deferredRenderTarget = input.get(RenderResourceType::RenderTarget)->renderTarget;
  RenderTarget* renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  IGraphicsDevice* device = context->renderer->getDevice();
  IContext* deviceContext = device->getImmediateContext();
 
  deviceContext->setEffect(effect->handle);
 
  deviceContext->setRenderTarget(renderTarget->renderTargetHandle, DepthStencilHandle::NoHandle);
 
  deviceContext->setViewport(
    0,
    0,
    context->renderer->getSize().x,
    context->renderer->getSize().y);
 
  deviceContext->setDepthStencilState(context->states->commonDepthStates[RenderStates::noTestDepthStencilState]);
  deviceContext->setRasterizerState(context->states->defaultRasterizerStateHandle);
  deviceContext->setBlendState(context->states->blendStates[size_t(BlendMode::None)].handle);
 
  applyGlobalBindings(context, bindings);
 
  const char * textureName[] = {
    "colorTexture",
    "emissiveTexture",
    "specularTexture",
    "normalTexture",
    "depthTexture"
  };
 
  deviceContext->setTexture("colorTexture", 0, deferredRenderTarget->get("Color"));
  deviceContext->setTexture("emissiveTexture", 1, deferredRenderTarget->get("Emissive"));
  deviceContext->setTexture("specularTexture", 2, deferredRenderTarget->get("Specular"));
  deviceContext->setTexture("normalTexture", 3, deferredRenderTarget->get("Normals"));
  deviceContext->setTexture("depthTexture", 4, deferredRenderTarget->depth->textureHandle);
 
  deviceContext->setVertexBuffers(nullptr, 0, nullptr, nullptr);
  deviceContext->setIndexBuffer(IndexBufferHandle::NoHandle);
  deviceContext->setInputLayout(InputLayoutHandle::NoHandle);
  deviceContext->draw(PrimitiveType::TriangleList, 0, 3);
 
  for (size_t i = 0; i < 5; ++i) {
    deviceContext->setTexture(textureName[i], 0, Cogs::TextureHandle::NoHandle);
  }
}
 
void Cogs::Core::DeferredLightingTask::initializeGlobalBindings(RenderTaskContext * context, CachedEffect * effect, GlobalBinding & bindings)
{
  auto effects = context->device->getEffects();
 
  bindings.sceneBufferBinding = effects->getConstantBufferBinding(effect->handle, "SceneBuffer");
 
  bindings.shadowArrayBinding = effects->getTextureBinding(effect->handle, "cascadedShadowMap", 1);
  bindings.shadowArrayBinding_1 = effects->getTextureBinding(effect->handle, "cascadedShadowMap_1", 1);
  bindings.shadowCubeArrayBinding = effects->getTextureBinding(effect->handle, "cubeShadowMap", 2);
  bindings.shadowCubeArrayBinding_1 = effects->getTextureBinding(effect->handle, "cubeShadowMap_1", 2);
  bindings.shadowSamplerBinding = effects->getSamplerStateBinding(effect->handle, "cascadedShadowSampler", 2);
 
  bindings.linearSampler = effects->getSamplerStateBinding(effect->handle, "linearSampler", 0);
  bindings.radianceSamplerBinding = effects->getSamplerStateBinding(effect->handle, "environmentRadianceSampler", 0);
  bindings.irradianceSamplerBinding = effects->getSamplerStateBinding(effect->handle, "environmentIrradianceSampler", 0);
  bindings.ambientIrradianceSamplerBinding = effects->getSamplerStateBinding(effect->handle, "ambientIrradianceSampler", 0);
}
 
void Cogs::Core::DeferredLightingTask::applyGlobalBindings(RenderTaskContext * context, GlobalBinding & bindings)
{
  auto deviceContext = context->device->getImmediateContext();
  auto engineBuffers = context->engineBuffers;
 
  if (HandleIsValid(bindings.sceneBufferBinding)) {
    deviceContext->setConstantBuffer(bindings.sceneBufferBinding, engineBuffers->sceneBufferHandle);
  }
 
  auto shadowsEnabled = context->context->variables->get("renderer.shadowsEnabled", false);
  auto lightSystem = context->context->lightSystem;
 
  if (shadowsEnabled) {
    if (HandleIsValid(bindings.shadowArrayBinding)) {
      auto shadowTexture = context->resources->getRenderTexture(lightSystem->cascadeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings.shadowArrayBinding, shadowTexture->textureHandle);
      }
    }
    if (HandleIsValid(bindings.shadowArrayBinding_1)) {
      auto shadowTexture = context->resources->getRenderTexture(lightSystem->cascadeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings.shadowArrayBinding_1, shadowTexture->textureHandle);
      }
    }
 
    if (HandleIsValid(bindings.shadowCubeArrayBinding)) {
      auto shadowTexture = context->resources->getRenderTexture(lightSystem->cubeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings.shadowCubeArrayBinding, shadowTexture->textureHandle);
      }
    }
    if (HandleIsValid(bindings.shadowCubeArrayBinding_1)) {
      auto shadowTexture = context->resources->getRenderTexture(lightSystem->cubeArray);
 
      if (shadowTexture) {
        deviceContext->setTexture(bindings.shadowCubeArrayBinding_1, shadowTexture->textureHandle);
      }
    }
 
    if (HandleIsValid(bindings.shadowSamplerBinding)) {
      deviceContext->setSamplerState(bindings.shadowSamplerBinding, context->states->shadowSampler);
    }
  }
  if (HandleIsValid(bindings.radianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings.radianceSamplerBinding, context->states->defaultSampler);
  }
  if (HandleIsValid(bindings.irradianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings.irradianceSamplerBinding, context->states->defaultSampler);
  }
  if (HandleIsValid(bindings.ambientIrradianceSamplerBinding)) {
    deviceContext->setSamplerState(bindings.ambientIrradianceSamplerBinding, context->states->defaultSampler);
  }
  if (HandleIsValid(bindings.brdfLUTSamplerBinding)) {
    deviceContext->setSamplerState(bindings.brdfLUTSamplerBinding, context->states->defaultSampler);
  }
  if (HandleIsValid(bindings.linearSampler)) {
    deviceContext->setSamplerState(bindings.linearSampler, context->states->defaultSampler);
  }
}