ComputeTask.cpp

#include "ComputeTask.h"
 
#include "Rendering/ICapabilities.h"
#include "Rendering/IContext.h"
#include "Rendering/IEffects.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Logging/Logger.h"
#include "Resources/ShaderBuilderPostProcess.h"
 
#include "Renderer/Renderer.h"
 
#include <cassert>
 
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ComputeTask");
}
 
void Cogs::Core::ComputeTask::initialize(RenderTaskContext * context)
{
  EffectDescription desc = {};
 
  for (auto & p : effectParameter.values) {
    if (p.key == "definitions") {
      for (auto & d : p.values) {
        desc.definitions.push_back({ d.key, d.value });
      }
    }
    else if (p.key == "source") {
      desc.cs = p.value;
    }
    else if (p.key == "useVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "setVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "useComponentFields") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "properties") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "groups" && p.values.size() == 3) {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "options") {
      // Handled in RenderTaskFactory.cpp
    }
    else{
      LOG_WARNING(logger, "Unknown compute task pipeline section \"%s\"", p.key.c_str());
    }
  }
 
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
}
 
void Cogs::Core::ComputeTask::initialize(RenderTaskContext* context, const RenderTaskDefinition& taskDefinition) {
  ProcessTask::initialize(context, taskDefinition);
  EffectDescription desc = {};
 
  for (auto& p : effectParameter.values) {
    if (p.key == "definitions") {
      for (auto& d : p.values) {
        desc.definitions.push_back({ d.key, d.value });
      }
    }
    else if (p.key == "source") {
      desc.cs = p.value;
    }
    else if (p.key == "useVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "setVariables") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "useComponentFields") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "properties") {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "groups" && p.values.size() == 3) {
      // Handled in RenderTaskFactory.cpp
    }
    else if (p.key == "options") {
      // Handled in RenderTaskFactory.cpp
    }
    else{
      LOG_WARNING(logger, "Unknown compute task pipeline section \"%s\"", p.key.c_str());
    }
  }
 
  {
    Cogs::GraphicsDeviceType graphicsDeviceType = context->renderer->getDevice()->getType();
    bool success = false;
    switch (graphicsDeviceType)
    {
#if 0
 
    case Cogs::GraphicsDeviceType::OpenGLES30:
      success = Cogs::Core::buildPostProcessEffectES3(context, desc, this);
      break;
    case Cogs::GraphicsDeviceType::WebGPU:
      success = buildPostProcessEffectWebGPU(context, desc);
      break;
#endif
    case Cogs::GraphicsDeviceType::Direct3D11:
    case Cogs::GraphicsDeviceType::OpenGL20:
      success = buildComputeEffect(context, desc, this);
      break;
    default:
      break;
    }
    if (!success) {
      LOG_ERROR(logger, "Failed to build post processing shader source");
    }
  }
 
  effect = context->renderer->getEffectCache().loadEffect(context, desc);
}
 
void Cogs::Core::ComputeTask::cleanup(RenderTaskContext * context)
{
  ProcessTask::cleanup(context);
}
 
Cogs::ResourceStatus Cogs::Core::ComputeTask::checkReady(RenderTaskContext * context)
{
  IEffects* effects = context->device->getEffects();
 
  Cogs::ResourceStatus status = HandleIsValid(effect->handle) ? effects->checkEffect(effect->handle) : Cogs::ResourceStatus::Error;
 
  if (status == Cogs::ResourceStatus::Error && effectStatus != Cogs::ResourceStatus::Error) {
    LOG_ERROR(logger, "Invalid compute effect handle.");
  }
 
  effectStatus = status;
  return effectStatus;
}
 
void Cogs::Core::ComputeTask::apply(RenderTaskContext * context)
{
  DynamicRenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "ComputeTask", (std::string("ComputeTask<") + name + ">::apply").c_str());
 
  assert(effectStatus == Cogs::ResourceStatus::Ready);
 
  auto device = context->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  if(!device->getCapabilities()->getDeviceCapabilities().RenderPass){
    // Reset render target to avoid input/output locks.
    deviceContext->setRenderTarget(RenderTargetHandle::NoHandle, DepthStencilHandle::NoHandle);
  }
 
  deviceContext->setEffect(effect->handle);
 
  setProperties(context);
 
  deviceContext->setSamplerState("linearSampler", 0, context->states->getSamplerState(SamplerState::DefaultState()));
 
  uint32_t groups[3] = { 1, 1, 1 };
 
  if (this->groups.expressions.size() == 3) {
    for (size_t i = 0; i < 3; i++) {
      groups[i] = this->scope->update(this->groups.expressions[i].second, 0);
    }
  }
  else {
    for (auto & ep : effectParameter.values) {
      if (ep.key != "groups") continue;
 
      for (uint32_t i = 0; i < 3; i++) {
        groups[i] = static_cast<uint32_t>(ep.float3Value[i]);
      }
    }
  }
 
  if (groups[0] && groups[1] && groups[2]) {
    deviceContext->dispatchCompute(groups[0], groups[1], groups[2]);
  } else {
    LOG_WARNING(logger, "Empty compute shader dimensions.");
  }
}