EffectCache.cpp

#include "EffectCache.h"
#include "Context.h"
 
#include "Resources/ResourceStore.h"
#include "Tasks/RenderTask.h"
#include "Services/Variables.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Platform/FileSystemWatcher.h"
#include "Foundation/Platform/IO.h"
 
namespace Cogs::Core
{
  size_t getCode(EffectDescription & desc)
  {
    size_t hashValue = hashSequence(desc.vs, desc.ps, desc.cs);
 
    for (const auto & def : desc.definitions) {
      hashValue = Cogs::hash(def.first, hashValue);
      hashValue = Cogs::hash(def.second, hashValue);
    }
    return hashValue;
  }
 
  void changeSuffix(std::string& dst, const std::string& from, const std::string& to)
  {
    auto pos = dst.find(from);
    if (pos == std::string::npos) return;
    dst.replace(pos, to.length(), to);
  }
 
}
 
void Cogs::Core::EffectCache::reload(RenderTaskContext * context)
{
  for (auto & p : effects) {
    reload(context, &p.second);
  }
}
 
void Cogs::Core::EffectCache::reload(RenderTaskContext * context, CachedEffect * effect)
{
  auto device = context->renderer->getDevice();
 
  if (HandleIsValid(effect->handle)) {
    device->getEffects()->releaseEffect(effect->handle);
  }
 
  context->context->resourceStore->purge("Shaders/" + effect->description.vs);
  context->context->resourceStore->purge("Shaders/" + effect->description.ps);
 
  effect->handle = device->getEffects()->loadEffect(effect->description.vs, effect->description.ps);
}
 
Cogs::Core::CachedEffect *  Cogs::Core::EffectCache::loadEffect(RenderTaskContext * context, EffectDescription & desc)
{
  const size_t code = getCode(desc);
 
  auto it = effects.find(code);
 
  if (it != effects.end() && it->second.usage) {
    assert(it->second.description.vs == desc.vs);
    assert(it->second.description.cs == desc.cs);
    assert(it->second.description.ps == desc.ps);
    ++it->second.usage;
    return &it->second;
  }
 
  Cogs::EffectHandle handle;
  if (!desc.cs.empty()) {
    std::string cs = desc.cs;
    switch (context->renderer->getDevice()->getType()) {
    case Cogs::GraphicsDeviceType::WebGPU:
      changeSuffix(cs, ".hlsl", ".wgsl");
      break;
    default:
      break;
    }
    handle = context->renderer->getDevice()->getEffects()->loadComputeEffect(cs, desc.definitions);
  } else {
    std::string vs, ps; // must be alive until loadEffect returns.
 
    auto name = IO::stem(desc.ps);
 
    Cogs::EffectDescription effectDesc = {};
    effectDesc.flags = context->renderer->getEffectFlags();
    switch (context->renderer->getDevice()->getType()) {
    case Cogs::GraphicsDeviceType::OpenGLES30:
      vs = desc.vs;
      ps = desc.ps;
      changeSuffix(vs, ".hlsl", ".es30.glsl");
      changeSuffix(ps, ".hlsl", ".es30.glsl");
      effectDesc.vertexShader = vs;
      effectDesc.pixelShader = ps;
      effectDesc.flags = static_cast<EffectFlags::EEffectFlags>(effectDesc.flags | EffectFlags::GLSL);
      break;
    case Cogs::GraphicsDeviceType::WebGPU:
      vs = desc.vs;
      ps = desc.ps;
      changeSuffix(vs, ".hlsl", ".wgsl");
      changeSuffix(ps, ".hlsl", ".wgsl");
      effectDesc.vertexShader = vs;
      effectDesc.pixelShader = ps;
      effectDesc.flags = static_cast<EffectFlags::EEffectFlags>(effectDesc.flags | EffectFlags::WGSL);
      break;
    default:
      effectDesc.vertexShader = desc.vs;
      effectDesc.pixelShader = desc.ps;
      break;
    }
    effectDesc.name = name;
    effectDesc.definitions = desc.definitions;
    effectDesc.bindGroupLayoutDesc = desc.bindGroupLayoutDesc;
 
    handle = context->renderer->getDevice()->getEffects()->loadEffect(effectDesc);
  }
 
  CachedEffect effect = { desc, handle, 1 };
  auto & cached = effects[code] = effect;
 
  if (context->context->watcher && context->context->variables->get("resources.effects.autoReload", false)) {
    if (desc.vs.size()) {
      context->context->watcher->watchFile(desc.vs, [&](const FileSystemWatcher::Event&) { reload(context, &cached); });
 
      if (desc.ps.size()) {
        context->context->watcher->watchFile(desc.ps, [&](const FileSystemWatcher::Event&) { reload(context, &cached); });
      }
    }
  }
 
  return &cached;
}
 
void Cogs::Core::EffectCache::release(RenderTaskContext * context, CachedEffect * effect)
{
  assert(effect->usage && "Effect already released.");
 
  if (--effect->usage == 0) {
    if (HandleIsValid(effect->handle)) {
      context->renderer->getDevice()->getEffects()->releaseEffect(effect->handle);
      effect->handle = Cogs::EffectHandle::NoHandle;
    }
  }
}
 
Cogs::Core::CachedEffect * Cogs::Core::EffectCache::loadEffect(RenderTaskContext * context, StringView cs)
{
  EffectDescription desc{};
  desc.cs = cs.to_string();
  return loadEffect(context, desc);
}
 
 
Cogs::Core::CachedEffect * Cogs::Core::EffectCache::loadEffect(RenderTaskContext * context, StringView vs, StringView ps)
{
  EffectDescription desc{};
  desc.vs = vs.to_string();
  desc.ps = ps.to_string();
 
  return loadEffect(context, desc);
}