EffectManager.cpp

#include "EffectManager.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IEffects.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Renderer/IRenderer.h"
 
#include "Services/Variables.h"
 
#include "ResourceStore.h"
 
#include "Context.h"
 
#include "ShaderBuilder.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectManager");
}
 
Cogs::Core::EffectManager::~EffectManager()
{
  reportLeaks("Effect");
}
 
void Cogs::Core::EffectManager::initialize()
{
  auto & dataDir = context->resourceStore->getDataDir();
 
  context->resourceStore->addSearchPath(dataDir + "Shaders/");
  context->resourceStore->addSearchPath("Shaders/");
  context->resourceStore->addSearchPath("shaders/");
}
 
void Cogs::Core::EffectManager::handleLoad(EffectLoadInfo * loadInfo)
{
  bool preLoad = context->variables->get("resources.effects.preLoad", false);
 
  if (preLoad) {
    if (!context->resourceStore->hasResources(loadInfo->dependencies)) {
      if (!loadInfo->preloading) {
        context->resourceStore->preloadResources(loadInfo->dependencies);
        loadInfo->preloading = true;
      }
 
      // Re-queue until all dependencies available.
      queueResource(loadInfo);
 
      return;
    }
  }
 
  auto effect = get(loadInfo->handle);
  effect->definition = std::move(loadInfo->definition);
 
  auto & definition = effect->definition;
 
  if(definition.vertexShader.loadPath.find(extension) == std::string::npos) {
 
    if (definition.vertexShader.loadPath.size()) {
      definition.vertexShader.loadPath += extension;
    }
 
    if (definition.hullShader.loadPath.size()) {
      definition.hullShader.loadPath += extension;
    }
 
    if (definition.domainShader.loadPath.size()) {
      definition.domainShader.loadPath += extension;
    }
 
    if (definition.geometryShader.loadPath.size()) {
      definition.geometryShader.loadPath += extension;
    }
 
    if (definition.pixelShader.loadPath.size()) {
      definition.pixelShader.loadPath += extension;
    }
  }
 
  setProcessed(loadInfo);
}
 
void Cogs::Core::EffectManager::handleReload(ResourceHandleBase handle)
{
  EffectHandle effect(handle);
 
  auto & loadInfo = *createLoadInfo();
  loadInfo.resourceId = effect->getId();
  loadInfo.resourcePath = effect->getSource().to_string();
  loadInfo.resourceName = effect->getName().to_string();
  loadInfo.loadFlags = ResourceLoadFlags::Reload;
  loadInfo.handle = handle;
  loadInfo.definition = effect->definition;
 
  loadResource(&loadInfo);
}
 
Cogs::Core::ActivationResult Cogs::Core::EffectManager::handleActivation(EffectHandle handle, Effect * /*effect*/)
{
  return context->renderer->getResources()->updateResource(handle);
}
 
Cogs::Core::EffectHandle Cogs::Core::EffectManager::loadEffect(const EffectDefinition & definition)
{
  switch (context->renderer->getDevice()->getType()) {
  case Cogs::GraphicsDeviceType::OpenGLES30:
    extension = ".es30.glsl";
    break;
  case Cogs::GraphicsDeviceType::WebGPU:
    extension = ".wgsl";
    break;
  default:
    extension = ".hlsl";
  }
 
  EffectLoadInfo & loadInfo = *createLoadInfo();
  loadInfo.definition = definition;
  loadInfo.resourceName = definition.name;
 
  for (auto & d : definition.dependencies) {
    loadInfo.dependencies.emplace_back("Shaders/" + d + extension);
  }
 
  if (definition.vertexShader.loadPath.size()) {
    loadInfo.dependencies.emplace_back("Shaders/" + definition.vertexShader.loadPath + extension);
  }
 
  if (definition.pixelShader.loadPath.size()) {
    loadInfo.dependencies.emplace_back("Shaders/" + definition.pixelShader.loadPath + extension);
  }
 
  return loadResource(&loadInfo);
}
 
void Cogs::Core::EffectManager::handleDeletion(Effect * resource)
{
  context->renderer->getResources()->releaseResource(resource);
}