ComputeTask.cpp

#include "ComputeTask.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
 
#include "Foundation/Logging/Logger.h"
#include "Resources/ShaderBuilderPostProcess.h"
 
#include "Renderer/Renderer.h"
 
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 });
      }
    }
    if (p.key == "source") {
      desc.cs = p.value;
    }
  }
 
  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 });
      }
    }
    if (p.key == "source") {
      desc.cs = p.value;
    }
  }
 
  {
    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);
}
 
void Cogs::Core::ComputeTask::apply(RenderTaskContext * context)
{
  DynamicRenderInstrumentationScope(context->device->getImmediateContext(), SCOPE_RENDERING, "ComputeTask", (std::string("ComputeTask<") + name + ">::apply").c_str());
 
  if (!HandleIsValid(effect->handle)) {
    LOG_ERROR(logger, "Invalid compute effect handle.");
    return;
  }
 
  auto device = context->renderer->getDevice();
  auto deviceContext = device->getImmediateContext();
 
  // 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.");
  }
}