RenderListTask.cpp

#include "RenderListTask.h"
#include "GenerateListTask.h"
#include "FilterListTask.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderMaterialInstance.h"
#include "Renderer/RenderResources.h"
#include "Renderer/RenderStateUpdater.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/EnginePermutations.h"
 
#include "Platform/Instrumentation.h"
 
#include "Context.h"
 
#include "Services/Time.h"
#include "Services/Variables.h"
 
#include "Rendering/ITextures.h"
#include "Rendering/IRenderTargets.h"
#include "Rendering/ICapabilities.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Collections/SmallVector.h"
 
#include <glm/glm.hpp>
#include <glm/gtc/color_space.hpp>
 
#include <sstream>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderListTask");
}
 
Cogs::Core::RenderListTask::RenderListTask()
{
}
 
Cogs::Core::RenderListTask::~RenderListTask()
{
}
 
void Cogs::Core::RenderListTask::initialize(RenderTaskContext * context)
{
  RenderTask::initialize(context);
 
  auto renderTargets = context->device->getRenderTargets();
 
  blendState = renderTargets->loadBlendState(&context->states->blendStates[size_t(blendMode)].color,
                                             &context->states->blendStates[size_t(blendMode)].alpha, 1, BlendFlags::IndependentBlend);
  depthState = context->states->commonDepthStates[(int)DepthMode::Count*(int)depthFunc+(int)depthMode];
 
  scopeName = context->renderer->getEnginePermutations().get(permutationIndex)->getName();
}
 
void Cogs::Core::RenderListTask::apply(RenderTaskContext * context)
{
  DynamicRenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "RenderListTask", scopeName.c_str());
 
  if (!validate(context, 1, 1)) return;
 
  const auto renderList = input.get(RenderResourceType::RenderList)->renderList;
  auto renderTarget = output.get(RenderResourceType::RenderTarget)->renderTarget;
 
  if (!renderList) {
    LOG_ERROR(logger, "Missing input render list for %s.", scopeName.c_str());
    return;
  }
 
  if (!renderTarget) {
    LOG_ERROR(logger, "Missing output target for %s.", scopeName.c_str());
    return;
  }
 
  if (isStatic()) {
    if (renderList->hash == lastHash) return;
    lastHash = renderList->hash;
  }
 
  if (renderList->viewportData->viewportSize.x == 0 || renderList->viewportData->viewportSize.y == 0) return;
 
  auto deviceContext = context->device->getImmediateContext();
 
  setupRenderTarget(context, renderTarget, renderList->viewportData);
 
  updateEngineBuffers(context, renderTarget, renderList->viewportData, nullptr);
 
  renderItems(context,
              renderTarget,
              renderList,
              bucketMask,
              stateChangeMask);
 
  if (context->device->getCapabilities()->getDeviceCapabilities().RenderPass &&
      !renderList->viewportData->bindRenderTargetCallback) {
    deviceContext->endRenderPass();
  }
 
  for (auto t : renderTarget->textures) {
    if (t->description.flags & TextureFlags::GenerateMipMaps) {
      context->device->getTextures()->generateMipmaps(t->textureHandle);
    }
  }
}
 
bool Cogs::Core::RenderListTask::validate(RenderTaskContext * /*context*/, size_t expectedInputs, size_t expectedOutputs)
{
  const bool validInputs = input.resources.size() >= expectedInputs;
  const bool validOutputs = output.resources.size() >= expectedOutputs;
 
  if (validInputs && validOutputs) {
    return true;
  } else {
    LOG_ERROR(logger, "Failed validating connections for %s.", scopeName.c_str());
    return false;
  }
}
 
void Cogs::Core::RenderListTask::applyMaterial(const DrawContext & drawContext, const RenderItem & item)
{
  updateEnvironmentBindings(&drawContext, item.binding);
 
  auto permutation = drawContext.permutation;
 
  for (auto & buffer : drawContext.permutation->constantBuffers.buffers) {
    permutation->bufferHandles.resize(permutation->constantBuffers.buffers.size());
    
    if (!HandleIsValid(permutation->bufferHandles[buffer.index])) {
      IBuffers* buffers = drawContext.device->getBuffers();
      permutation->bufferHandles[buffer.index] = buffers->loadBuffer(nullptr, buffer.size, Usage::Dynamic, AccessMode::Write, BindFlags::ConstantBuffer);
      buffers->annotate(permutation->bufferHandles[buffer.index], "RenderListTask::applyMaterial");
    }
 
    drawContext.deviceContext->updateBuffer(permutation->bufferHandles[buffer.index], buffer.content.data(), buffer.size);
    drawContext.deviceContext->setConstantBuffer(buffer.name, permutation->bufferHandles[buffer.index]);
  }
}
 
void Cogs::Core::RenderListTask::renderBatched(RenderTaskContext * taskContext,
                                               DrawContext & drawContext,
                                               const RenderList* renderList,
                                               const RenderItems & items,
                                               BucketMask /*bucketMask*/,
                                               StateChangeFlags stateChangeMask,
                                               bool batched)
{
  auto renderer = taskContext->renderer;
  auto device = renderer->getDevice();
 
  auto context = device->getImmediateContext();
 
  auto setViewport = [&](const CameraData & c) {
    context->setViewport(
      c.viewportOrigin.x,
      c.viewportOrigin.y,
      (!viewportFromTarget && (c.viewportSize.x != 0)) ? c.viewportSize.x : static_cast<float>(defaultViewportSize.x),
      (!viewportFromTarget && (c.viewportSize.y != 0)) ? c.viewportSize.y : static_cast<float>(defaultViewportSize.y));
  };
 
  size_t o = 0;
  size_t n = items.size();
  while (o < n) {
 
    size_t m = batched ? populateObjectBuffer(&drawContext, items.data(), o, n) : o + 1;
 
    for (size_t i = o; i < m; i++) {
      const RenderItem & currentItem = items[i];
 
      if (currentItem.isCustom1()) {
        (*currentItem.callback)(taskContext, &drawContext, &currentItem);
        continue;
      }
      if (currentItem.isCustom2()) {
        (*currentItem.callback2)(taskContext, &drawContext, this, &currentItem);
        continue;
      }
 
      const StateChangeFlags stateChanges = currentItem.stateChanges & stateChangeMask;
 
      if ((stateChanges & StateChangeFlags::ChangeViewport) != 0) {
        setViewport(*drawContext.cameraData);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeDepthStencilState) != 0) {
        context->setDepthStencilState(taskContext->states->commonDepthStates[currentItem.depthState]);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeBlendState) != 0) {
        context->setBlendState(taskContext->states->blendStates[currentItem.blendState].handle);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeRasterizerState) != 0) {
        context->setRasterizerState(taskContext->states->rasterizerStateHandles[currentItem.rasterizerState]);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeViewportData) != 0) {
        const ClipShapeCache::Item& clipShape = renderList->clipShapeCache->data[currentItem.clipShapeIx];
        updateViewportBuffer(taskContext, taskContext->engineBuffers->sceneBufferHandle, taskContext->engineBuffers->viewBufferHandle, drawContext.renderTarget, currentItem.viewportData ? currentItem.viewportData : drawContext.cameraData, &clipShape.clipEquations);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeMaterialVariant) != 0) {
        applyMaterialPermutation(taskContext, &drawContext, currentItem.binding, currentItem.renderMaterialInstance);
 
        applyMaterial(drawContext, currentItem);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeMaterialInstance) != 0) {
        applyMaterialInstance(&drawContext, currentItem.binding, currentItem.renderMaterialInstance);
      }
 
      if ((stateChanges & StateChangeFlags::ChangeMesh) != 0) {
 
        if (HandleIsValid(currentItem.vertexArrayObject)) {
          context->setVertexArrayObject(currentItem.vertexArrayObject);
        }
        else {
          context->setVertexBuffers(currentItem.meshData->vertexBuffers, currentItem.meshData->streamsLayout.numStreams, currentItem.meshData->vertexStrides, currentItem.meshData->vertexOffsets);
 
          if (currentItem.meshData->indexBuffer != IndexBufferHandle::NoHandle) {
            context->setIndexBuffer(currentItem.meshData->indexBuffer, currentItem.meshData->indexStride, currentItem.meshData->indexOffset);
          }
 
        }
      }
      if (batched) {
        applyMaterialPerObjectBatched(&drawContext, currentItem.renderMaterialInstance, currentItem, i - o);
      }
      else {
        applyMaterialPerObject(&drawContext, currentItem.renderMaterialInstance, currentItem);
      }
 
      if (currentItem.isInstanced()) {
 
        if (currentItem.instanceData) {
          auto renderMesh = currentItem.meshData;
          auto instanceMesh = currentItem.instanceData;
 
          assert(renderMesh && instanceMesh && "Invalid instanced rendering data.");
          assert(renderMesh->streamsLayout.numStreams && instanceMesh->streamsLayout.numStreams && "Missing instanced render buffers.");
          assert(renderMesh->streamsLayout.numStreams + instanceMesh->streamsLayout.numStreams <= MeshStreamsLayout::maxStreams);
 
          Cogs::VertexBufferHandle vertexBuffers[MeshStreamsLayout::maxStreams];
          uint32_t strides[MeshStreamsLayout::maxStreams];
          uint32_t offsets[MeshStreamsLayout::maxStreams];
 
          // Add vertex streams
          size_t numStreams = 0;
          for (size_t j = 0; j < renderMesh->streamsLayout.numStreams; j++) {
            vertexBuffers[numStreams] = renderMesh->vertexBuffers[j];
            strides[numStreams] = renderMesh->vertexStrides[j];
            offsets[numStreams] = renderMesh->vertexOffsets[j];
            numStreams++;
          }
 
          // Add instance streams
          for (size_t j = 0; j < instanceMesh->streamsLayout.numStreams; j++) {
            vertexBuffers[numStreams] = instanceMesh->vertexBuffers[j];
            strides[numStreams] = instanceMesh->vertexStrides[j];
            offsets[numStreams] = instanceMesh->vertexOffsets[j];
            numStreams++;
          }
 
          context->setVertexBuffers(vertexBuffers, numStreams, strides, offsets);
        }
 
        if (currentItem.meshData->indexBuffer) {
          context->setIndexBuffer(currentItem.meshData->indexBuffer);
          context->drawInstancedIndexed(currentItem.primitiveType, currentItem.startInstance, currentItem.numInstances, currentItem.startIndex, currentItem.numIndexes);
        } else {
          context->drawInstanced(currentItem.primitiveType, currentItem.startIndex, currentItem.numIndexes, currentItem.startInstance, currentItem.numInstances);
        }
 
      } else {
        if (currentItem.meshData->indexBuffer != IndexBufferHandle::NoHandle) {
          context->drawIndexed(currentItem.primitiveType, currentItem.startIndex, currentItem.numIndexes);
        } else {
          context->draw(currentItem.primitiveType, currentItem.startIndex, currentItem.numIndexes);
        }
      }
    }
 
    o = m;
  }
 
 
}
 
void Cogs::Core::RenderListTask::setupRenderTarget(RenderTaskContext * context, RenderTarget * renderTarget, const CameraData * viewportData)
{
  defaultViewportSize.x = renderTarget->width;
  defaultViewportSize.y = renderTarget->height;
 
  auto deviceContext = context->device->getImmediateContext();
 
  const RenderSettings& renderSettings = context->renderer->getSettings();
  MaterialOptions defaultMaterialOptions;
  RenderPassOptions defaultPassOptions;
 
  const bool isBackBuffer =
    !HandleIsValid(renderTarget->renderTargetHandle) &&
    !HandleIsValid(renderTarget->depthTargetHandle);
  const bool doScissor = viewportData->passOptions &&
    viewportData->passOptions->getFlag(RenderPassOptions::Flags::ScissorTest);
  bool doColorClear = colorClear &&
    (HandleIsValid(renderTarget->renderTargetHandle) || !HandleIsValid(renderTarget->depthTargetHandle));
  bool doDepthClear = depthClear &&
    (HandleIsValid(renderTarget->depthTargetHandle) || isBackBuffer);
  if (isBackBuffer && (renderSettings.defaultRenderTargetClear == false)) {
    doColorClear = false;
    doDepthClear = false;
  }
  bool isCleared = false;
 
  size_t nt = renderTarget->textures.size();
  size_t no = std::max(size_t(1), nt);
  glm::vec4 clearColorSRGB;
  Collections::SmallVector<const float*, 8> clearColors(no);
  {
    glm::vec4 black(0.f);
 
    size_t nc = renderTarget->clearColors.size();
 
    for (size_t i = 0; i < no; i++) {
 
      clearColors[i] = i == 0 ? glm::value_ptr(viewportData->useClearColor ? viewportData->clearColor : context->renderer->getBackgroundColor()) : glm::value_ptr(black);
 
      if (i < nt && renderTarget->textures[i]->clearColorSet) {
        clearColors[i] = renderTarget->textures[i]->clearColor;
      }
 
      else if (i < nc) {
        clearColors[i] = glm::value_ptr(renderTarget->clearColors[i]);
      }
    }
 
    if (no == 1) {
      if ((isBackBuffer && renderSettings.defaultRenderTargetExpectsSRGB) || renderTarget->expectsSRGB) {
        clearColorSRGB = glm::vec4(glm::convertLinearToSRGB(glm::make_vec3(clearColors[0])), clearColors[0][3]);
        clearColors[0] = glm::value_ptr(clearColorSRGB);
      }
    }
  }
 
  if (viewportData->bindRenderTargetCallback) {
    viewportData->bindRenderTargetCallback(viewportData->bindRenderTargetCallbackData);
  }
  else {
    if(context->device->getCapabilities()->getDeviceCapabilities().RenderPass){
      RenderPassInfo info;
      info.renderTargetHandle = renderTarget->renderTargetHandle;
      info.depthStencilHandle = renderTarget->depthTargetHandle;
      for (size_t i = 0; i < no; i++) {
        info.loadOp[i] = doColorClear ? LoadOp::Clear : LoadOp::Load;
        info.storeOp[i] = discardColor ? StoreOp::Discard : StoreOp::Store;
        info.clearValue[i][0] = clearColors[i][0];
        info.clearValue[i][1] = clearColors[i][1];
        info.clearValue[i][2] = clearColors[i][2];
        info.clearValue[i][3] = clearColors[i][3];
      }
      info.depthLoadOp = doDepthClear ? LoadOp::Clear : LoadOp::Load;
      info.depthStoreOp = discardDepth ? StoreOp::Discard : StoreOp::Store;
      info.depthClearValue = context->renderer->getClearDepth();
      info.depthReadOnly = !depthWrite;
      deviceContext->beginRenderPass(info);
      isCleared = true;
    }
    else{
      deviceContext->setRenderTarget(renderTarget->renderTargetHandle, renderTarget->depthTargetHandle);
    }
  }
 
  if (doScissor || doColorClear || doDepthClear || viewportData->bindRenderTargetCallback) {
    // E.g. scissor test affects clears.'
    // The bindRenderTargetCallback might change rasterization state.
    uint16_t rasterizerStateIx = context->states->getRasterizerState(viewportData->passOptions ? *viewportData->passOptions : defaultPassOptions,
                                                                     Cogs::RasterizerState::Back,
                                                                     false, // RenderMode::Normal,
                                                                     true);
    RasterizerStateHandle& rasterizerStateHandle = context->states->rasterizerStateHandles[rasterizerStateIx];
    deviceContext->setRasterizerState(rasterizerStateHandle);
  }
 
  if (doScissor) {
    auto & rect = viewportData->passOptions->scissorRectangle;
    deviceContext->setScissor(rect.x, rect.y, rect.z, rect.w);
  }
 
  if(!context->device->getCapabilities()->getDeviceCapabilities().RenderPass){
    if (doColorClear && !isCleared) {
      if (no == 1) {
        deviceContext->clearRenderTarget(clearColors[0]);
      }
      else {
        deviceContext->clearRenderTarget((const float**)clearColors.data(), static_cast<int>(nt));
      }
    }
 
    if (doDepthClear && !isCleared) {
      deviceContext->clearDepth(context->renderer->getClearDepth());
    }
  }
 
  deviceContext->setBlendState(blendState);
  deviceContext->setDepthStencilState(depthState);
}
 
void Cogs::Core::RenderListTask::renderItems(RenderTaskContext * taskContext,
                                             RenderTarget* renderTarget,
                                             const RenderList* renderList,
                                             BucketMask bucketMask,
                                             StateChangeFlags stateChangeMask)
{
  auto renderer = taskContext->renderer;
  auto device = taskContext->device;
  char buffer[ 128 ];
 
  std::sprintf(buffer, "mask=0x%08X", static_cast<int>(bucketMask));
  DynamicRenderInstrumentationScope(taskContext->device->getImmediateContext(), SCOPE_RENDERING, "RenderListTask::renderItems", buffer);
 
  auto enginePermutation = renderer->getEnginePermutations().get(permutationIndex);
 
  if(temporalOffsets){
    uint32_t frame = taskContext->context->time->getFrame();
    uint32_t widthDivisor = taskContext->context->variables->get("renderer.oit.TemporalUpscaleWidth", 1);
    uint32_t heightDivisor = taskContext->context->variables->get("renderer.oit.TemporalUpscaleHeight", 1);
    uint32_t i = frame % (widthDivisor * heightDivisor);
    uint32_t w = i%widthDivisor;
    uint32_t h = (i/widthDivisor)%heightDivisor;
 
    CameraData &viewportData(*(CameraData*)renderList->viewportData);
    viewportData.projectionMatrix = taskContext->renderer->getProjectionMatrix(viewportData.rawProjectionMatrix);
    viewportData.projectionMatrix[2][0] += (float)w*(2.0f/widthDivisor)/(float)renderTarget->width;
    viewportData.projectionMatrix[2][1] -= (float)h*(2.0f/heightDivisor)/(float)renderTarget->height;
    viewportData.viewProjection = viewportData.projectionMatrix * viewportData.viewMatrix;
    viewportData.inverseViewProjectionMatrix = glm::inverse(viewportData.viewProjection);
    viewportData.inverseProjectionMatrix = glm::inverse(viewportData.projectionMatrix);
  }
 
  DrawContext drawContext;
  drawContext.context = taskContext->context;
  drawContext.renderer = renderer;
  drawContext.device = device;
  drawContext.deviceContext = device->getImmediateContext();
  drawContext.cameraData = renderList->viewportData;
  drawContext.permutationIndex = enginePermutation->getIndex();
  drawContext.permutation = enginePermutation;
  drawContext.engineBuffers = &renderer->getEngineBuffers();
  drawContext.renderTarget = renderTarget;
  drawContext.taskContext = taskContext;
  drawContext.task = this;
  drawContext.listObjectBuffer = renderList->listObjectBuffer;
  drawContext.clipShapeCache = renderList->clipShapeCache;
 
  bool batchObjectBuffer = drawContext.engineBuffers->objectBatch.count != 0;
  const StringView batchObjectBufferKey = "renderer.batchObjectBuffer";
  if (Variable* var = drawContext.context->variables->get(batchObjectBufferKey); !var->isEmpty()) {
    batchObjectBuffer = var->getBool();
  }
  else {
    drawContext.context->variables->set(batchObjectBufferKey, batchObjectBuffer);
  }
 
  // list object buffer has presendence
  if (drawContext.listObjectBuffer && drawContext.listObjectBuffer->isInUse()) {
    objectBufferMode = ObjectBufferMode::List;
    batchObjectBuffer = false;
  }
  else if (drawContext.engineBuffers->objectBatch.count && batchObjectBuffer) {
    objectBufferMode = ObjectBufferMode::Batched;
  }
  else {
    objectBufferMode = ObjectBufferMode::Single;
    batchObjectBuffer = false;
  }
 
  for (size_t b = 0; b < size_t(BucketType::Count); b++) {
    if ((BucketMask(1 << b) & bucketMask) == 0) continue;
 
    const RenderItems & items = renderList->buckets[b];
    renderBatched(taskContext, drawContext, renderList, items, bucketMask, stateChangeMask, batchObjectBuffer);
  }
 
  if(temporalOffsets){
    CameraData &viewportData(*(CameraData*)renderList->viewportData);
    viewportData.projectionMatrix = taskContext->renderer->getProjectionMatrix(viewportData.rawProjectionMatrix);
    viewportData.viewProjection = viewportData.projectionMatrix * viewportData.viewMatrix;
    viewportData.inverseViewProjectionMatrix = glm::inverse(viewportData.viewProjection);
    viewportData.inverseProjectionMatrix = glm::inverse(viewportData.projectionMatrix);
  }
}