TransparencyRenderTask.cpp

#include "TransparencyRenderTask.h"
 
#include "Rendering/ITextures.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderBuffer.h"
#include "Renderer/RenderTarget.h"
 
#include "Renderer/RenderStateUpdater.h"
 
namespace Cogs
{
  namespace Core
  {
    struct TransparencyParameters
    {
      uint32_t allocated;
      uint32_t width;
    };
  }
}
 
void Cogs::Core::TransparencyRenderTask::initialize(RenderTaskContext * context)
{
  parameterHandle = context->renderer->getDevice()->getBuffers()->loadBuffer(nullptr, sizeof(TransparencyParameters), Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
}
 
void Cogs::Core::TransparencyRenderTask::apply(RenderTaskContext * context)
{
  RenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "TransparencyRenderTask::apply");
 
  auto renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  auto listTarget = output.get("ListBuffer")->renderBuffer;
  auto nodeTarget = output.get("NodeBuffer")->renderBuffer;
  auto dataTarget = output.get("DataBuffer")->renderBuffer;
 
  auto renderer = context->renderer;
  auto device = renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  auto renderList = input.get(RenderResourceType::RenderList)->renderList;
 
  // setupRenderTarget
  defaultViewportSize.x = renderTarget->width;
  defaultViewportSize.y = renderTarget->height;
  deviceContext->setRenderTarget(RenderTargetHandle::InvalidHandle, renderTarget->depthTargetHandle);
  deviceContext->setDepthStencilState(renderer->getRenderStates().noWriteDepthStencilStateHandle);
  deviceContext->setBlendState(renderer->getRenderStates().blendStates[size_t(BlendMode::None)].handle);
 
  transparencyContext = TransparencyDrawContext{
    listTarget->buffer,
    nodeTarget->buffer,
    dataTarget->buffer,
    parameterHandle,
  };
 
  deviceContext->setBufferCounter(transparencyContext.fragmentNodeBuffer, 0);
  {
    MappedBuffer<TransparencyParameters> parameters(deviceContext, transparencyContext.parameterBuffer, MapMode::WriteDiscard);
 
    if (parameters) {
      parameters->allocated = static_cast<int>(nodeTarget->bufferSize);
      parameters->width = renderTarget->width;
    }
  }
 
  permutationIndex = renderer->getEnginePermutations().getIndex("Transparent");
 
  // mask out change rasterizer state?
  renderItems(context,
              renderTarget,
              renderList,
              bucketMask,
              StateChangeFlags::ChangeAll & ~(StateChangeFlags::ChangeDepthStencilState | StateChangeFlags::ChangeBlendState));
}
 
void Cogs::Core::TransparencyRenderTask::cleanup(RenderTaskContext * context)
{
  context->renderer->getDevice()->getBuffers()->releaseBuffer(parameterHandle);
}
 
void Cogs::Core::TransparencyRenderTask::applyMaterial(const DrawContext & drawContext, const RenderItem & item)
{
  RenderListTask::applyMaterial(drawContext, item);
 
  auto deviceContext = drawContext.deviceContext;
 
  deviceContext->setConstantBuffer("TransparencyParameters", transparencyContext.parameterBuffer);
  deviceContext->setBuffer("List", transparencyContext.listBuffer);
  deviceContext->setBuffer("Node", transparencyContext.fragmentNodeBuffer);
  deviceContext->setBuffer("Data", transparencyContext.fragmentDataBuffer);
}