RenderEffect.cpp

#include "RenderEffect.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IEffects.h"
#include "Rendering/IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
 
#include "Resources/Material.h"
 
#include "Renderer.h"
#include "RenderResources.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderEffect");
 
  bool checkAndLogEffectLoad(Effect* effect, Cogs::EffectHandle effectHandle, Cogs::InputLayoutHandle inputHandle)
  {
    bool success = true;
    if (!HandleIsValid(effectHandle)) {
      LOG_ERROR(logger, "Error loading effect %s, definition:", effect->getName().data());
      success = false;
    }
 
    if (success && !HandleIsValid(inputHandle)) { // Input layout will always fail if effect is invalid, no point in reporting
      LOG_WARNING(logger, "Could not create input layout for %.*s, definition:", StringViewFormat(effect->getName()));
      success = false;
    }
 
    if(!success) {
      effect->definition.streamsLayout.logLayout(logger);
      for (const Cogs::PreprocessorDefinition& d : effect->definition.definitions) {
        LOG_DEBUG(logger, "+- #define %s %s", d.first.c_str(), d.second.c_str());
      }
      if (effect->definition.definitions.empty()) {
        LOG_DEBUG(logger, "+- No #define's");
      }
      const ShaderDefinition& vs = effect->definition.vertexShader;
      for (const ShaderInterfaceMemberDefinition& i : vs.shaderInterface.members) {
        LOG_DEBUG(logger, "  +- Vertex shader input semantic %.*s", StringViewFormat(ShaderInterfaceMemberDefinition::semanticNameString(i.semantic.name)));
      }
      if (effect->definition.vertexShader.shaderInterface.members.empty()) {
        LOG_DEBUG(logger, "+- No vertex shader input semantics");
      }
    }
 
    return success;
  }
 
 
}
 
Cogs::Core::ActivationResult Cogs::Core::RenderEffect::update(Effect * effect, IGraphicsDevice * device, RenderResources * resources)
{
  if (effect->delayLoad) {
    setDelayed();
 
    return ActivationResult::Delayed;
  }
 
  Context* context = resources->getContext();
  Renderer* renderer = resources->getRenderer();
 
  const bool updateAsync = context->variables->get("resources.effects.updateAsync", false);
 
  IEffects* effects = device->getEffects();
  IBuffers* buffers = device->getBuffers();
 
  if (haveQueued) {
    effectHandle = queuedEffectHandle;
    queuedEffectHandle = Cogs::EffectHandle::NoHandle;
 
    inputHandle = queuedInputHandle;
    queuedInputHandle = Cogs::InputLayoutHandle::NoHandle;
 
    task = NoTask;
    haveQueued = false;
 
    if (!checkAndLogEffectLoad(effect, effectHandle, inputHandle)) {
 
      if (effect->material) {
        effect->material->setChanged();
      }
 
      setFailed();
 
      return ActivationResult::Failure;
    }
 
    if (effect->material) {
      effect->material->setChanged();
    }
 
    incrementGeneration();
    setActive();
 
    return ActivationResult::Success;
  }
 
  if (updateAsync) {
    if (!task.isValid()) {
      Cogs::EffectDescription description = {};
      description.flags = renderer->getEffectFlags();
      description.vertexShader = effect->definition.vertexShader.loadPath;
      description.hullShader = effect->definition.hullShader.loadPath;
      description.domainShader = effect->definition.domainShader.loadPath;
      description.geometryShader = effect->definition.geometryShader.loadPath;
      description.pixelShader = effect->definition.pixelShader.loadPath;
      description.definitions = effect->definition.definitions;
 
      task = context->taskManager->enqueue(TaskManager::ResourceQueue, [this, effects, description, buffers, effect]()
      {
        queuedEffectHandle = effects->loadEffect(description);
        queuedInputHandle = queuedEffectHandle
          ? buffers->loadInputLayout(effect->definition.streamsLayout.vertexFormats,
                                     effect->definition.streamsLayout.numStreams,
                                     queuedEffectHandle)
          : Cogs::InputLayoutHandle::NoHandle;
 
        haveQueued = true;
      });
 
      setDelayed();
    }
 
    return ActivationResult::Postponed;
  }
  else {
    if (!HandleIsValid(effectHandle)) {
      // First time through: issue the load. This is a cheap call even on backends that compile
      // shaders asynchronously internally (e.g. WebGL, WebGPU) - the returned handle may not be
      // usable yet, its readiness is tracked via checkEffect() below.
      Cogs::EffectDescription description = {};
      description.flags = renderer->getEffectFlags();
      description.name = effect->getName();
      description.vertexShader = effect->definition.vertexShader.loadPath;
      description.hullShader = effect->definition.hullShader.loadPath;
      description.domainShader = effect->definition.domainShader.loadPath;
      description.geometryShader = effect->definition.geometryShader.loadPath;
      description.pixelShader = effect->definition.pixelShader.loadPath;
      description.definitions = effect->definition.definitions;
      description.bindGroupLayoutDesc = effect->definition.bindGroupLayouts;
 
      if (description.vertexShader.find("glsl") != StringView::NoPosition) {
        description.flags = static_cast<EffectFlags::EEffectFlags>(description.flags | EffectFlags::GLSL);
      }
 
      effectHandle = effects->loadEffect(description);
 
      if (!HandleIsValid(effectHandle)) {
        LOG_ERROR(logger, "Error loading effect %s.", effect->getName().data());
 
        if (effect->material) {
          effect->material->setChanged();
        }
 
        setFailed();
 
        return ActivationResult::Failure;
      }
 
      setDelayed();
    }
 
    switch (effects->checkEffect(effectHandle)) {
    case Cogs::ResourceStatus::Pending:
      // Still compiling on the backend side, retry next frame.
      return ActivationResult::Postponed;
 
    case Cogs::ResourceStatus::Error:
      LOG_ERROR(logger, "Error loading effect %s.", effect->getName().data());
 
      if (effect->material) {
        effect->material->setChanged();
      }
 
      setFailed();
 
      return ActivationResult::Failure;
 
    case Cogs::ResourceStatus::Ready:
    default:
      break;
    }
 
    // The effect is ready, its shader reflection can now be used to build the matching input layout.
    inputHandle = buffers->loadInputLayout(effect->definition.streamsLayout.vertexFormats,
                                           effect->definition.streamsLayout.numStreams,
                                           effectHandle);
 
    if (!checkAndLogEffectLoad(effect, effectHandle, inputHandle)) {
      LOG_ERROR(logger, "Error loading effect %s.", effect->getName().data());
 
      if (effect->material) {
        effect->material->setChanged();
      }
 
      setFailed();
 
      return ActivationResult::Failure;
    }
 
    if (effect->material) {
      effect->material->setChanged();
    }
 
    // Let dependent resources know the effect has been (re)loaded.
    ++generation;
 
    setActive();
 
    return ActivationResult::Success;
  }
}
 
void Cogs::Core::RenderEffect::release(Renderer * renderer)
{
  IGraphicsDevice* device = renderer->getDevice();
  IEffects* effects = device->getEffects();
  IBuffers* buffers = device->getBuffers();
 
  if (HandleIsValid(effectHandle)) {
    effects->releaseEffect(effectHandle);
    effectHandle = Cogs::EffectHandle::NoHandle;
  }
  if (HandleIsValid(inputHandle)) {
    buffers->releaseInputLayout(inputHandle);
    inputHandle = Cogs::InputLayoutHandle::NoHandle;
  }
 
  setReleased();
}
 
void Cogs::Core::RenderEffect::requestLoad()
{
  getResource()->delayLoad = false;
  getResource()->setChanged();
}