RenderPipelineFactory.cpp

#include "RenderPipelineFactory.h"
 
#include "Context.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderPipelineManager.h"
 
#include "Resources/Texture.h"
#include "Resources/TextureManager.h"
 
#include "Tasks/RenderTask.h"
 
#include "Utilities/Parsing.h"
 
#include "RenderResources.h"
 
#include "RenderTexture.h"
#include "RenderTarget.h"
#include "RenderBuffer.h"
#include "RenderList.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderPipelineFactory");
}
 
namespace Cogs::Core
{
  bool evaluateCondition(Context * context,
                         const StringView & condition,
                         const RenderPipelineDefinition & pipelineDefinition,
                         const std::vector<ParsedValue>& attributes)
  {
    thread_local static std::vector<StringView> tokens;
    tokens.clear();
 
    if (!condition.size()) return true;
 
 
    split(condition, "$=", tokens);
 
    assert((tokens.size() % 2 == 0) && "Token array must be multiple of two");
 
    bool totalConditionMet = true;
 
    for (size_t i = 0; i < tokens.size(); i += 2) {
      bool conditionMet = false;
 
      const auto key = tokens[i];
      const auto expected = tokens[i + 1];
 
      for (auto & o : pipelineDefinition.options) {
        if (key == o.key) {
          bool handled = false;
 
          // First, check attributes
          for (const auto & attribute : attributes) {
            if (key != StringView(attribute.key)) continue;
 
            handled = true;
            if (StringView(attribute.value) == expected) {
              conditionMet = true;
              break;
            }
          }
 
          StringView def("");
          if (!o.values.empty()) {
            def = o.values.front();
          }
 
          if (!handled && !o.setting.empty()) {
            // Otherwise, check variables.
            const auto setting = context->variables->get(o.setting, def);
            if (!setting.empty()) {
              if (setting == expected) {
                conditionMet = true;
                break;
              }
              handled = true;
            }
          }
          if (!handled && !def.empty()) {
            // And finally revert to default value.
            if (def == expected) {
              conditionMet = true;
              break;
            }
          }
        }
      }
 
      totalConditionMet = totalConditionMet && conditionMet;
    }
    return totalConditionMet;
  }
 
  void evaluateTaskDependencies(std::list<RenderTask *> tasks, const RenderTaskResources & globalResources, RenderPipeline & pipeline)
  {
    auto findResource = [&](const RenderTask * task, const RenderTaskResource & input, bool allow_self_dependency) -> bool
    {
      auto globalResource = globalResources.get(input.name);
 
      if (globalResource) {
        return true;
      }
 
      if (input.resource->isPersistent()) {
        return true;
      }
 
      if(allow_self_dependency){
        auto t = task;
        for (auto & output : t->output.resources) {
          if (output.resource->getName() == input.resource->getName()) {
            return true;
          } else if (input.type == RenderResourceType::RenderTexture && output.type == RenderResourceType::RenderTarget) {
            for (auto & texture : output.renderTarget->textures) {
              if (texture->getName() == input.resource->getName()) {
                return true;
              }
            }
            if (output.renderTarget->depth) {
              if (output.renderTarget->depth->getName() == input.resource->getName()) {
                return true;
              }
            }
          }
        }
      }
      for (auto & t : pipeline.tasks) {
        for (auto & output : t->output.resources) {
          if (output.resource->getName() == input.resource->getName()) {
            return true;
          } else if (input.type == RenderResourceType::RenderTexture && output.type == RenderResourceType::RenderTarget) {
            for (auto & texture : output.renderTarget->textures) {
              if (texture->getName() == input.resource->getName()) {
                return true;
              }
            }
            if (output.renderTarget->depth) {
              if (output.renderTarget->depth->getName() == input.resource->getName()) {
                return true;
              }
            }
          }
        }
      }
 
      return false;
    };
 
    auto findDependency = [&](const RenderTask * task, const StringView & d, bool allow_self_dependency) -> bool
    {
      if(allow_self_dependency){
        for(auto & o : task->output.resources) {
          if (d == o.name) {
            return true;
          }
        }
      }
      for (auto & t : pipeline.tasks) {
        if (d == t->name) {
          return true;
        }
 
        for (auto & o : t->output.resources) {
          if (d == o.name) {
            return true;
          }
        }
      }
 
      return false;
    };
 
    auto findPrerequisites = [&](const RenderTask * task) -> bool
    {
      bool foundResources = true;
      bool foundDependencies = true;
      bool allowSelfDependency = task->allowSelfDependency;
 
      for (auto & input : task->input.resources) {
        foundResources &= findResource(task, input, allowSelfDependency);
      }
 
      for (auto & d : task->dependencies) {
        foundDependencies &= findDependency(task, d, allowSelfDependency);
      }
 
      return foundResources && foundDependencies;
    };
 
    while (tasks.size()) {
      auto nextTaskIt = std::find_if(tasks.begin(), tasks.end(), findPrerequisites);
 
      if (nextTaskIt != tasks.end()) {
        pipeline.tasks.push_back(*nextTaskIt);
        tasks.erase(nextTaskIt);
      } else {
        LOG_ERROR(logger, "Unable to determine processing order for the following tasks:");
        for (auto task : tasks) {
          LOG_ERROR(logger, "  %s", task->name.c_str());
        }
        break;
      }
    }
  }
 
  bool addVariable(ExpressionContext * expressionContext, StringView name, const ParsedValue & p)
  {
    if (p.type == ParsedDataType::Float) {
      expressionContext->add(name, p.floatValue);
    } else if (p.type == ParsedDataType::Int) {
      expressionContext->add(name, p.intValue);
    } else if (p.type == ParsedDataType::UInt) {
      expressionContext->add(name, p.uintValue);
    } else if (p.type == ParsedDataType::Bool) {
      expressionContext->add(name, p.boolValue ? 1 : 0);
    } else if (p.type == ParsedDataType::String) {
      expressionContext->add(name, parseDouble(p.value, 0));
    } else {
      LOG_ERROR(logger, "Invalid variable type for %.*s", StringViewFormat(name));
      return false;
    }
 
    return true;
  }
 
  RenderBuffer * createRenderBuffer(RenderResources * renderResources, const std::string & resourceName, const RenderResourceDefinition & r, ExpressionContext * expressionContext)
  {
    auto renderBuffer = renderResources->createRenderBuffer();
    renderBuffer->setName(resourceName);
    if (r.getParameter("persistent", false)) {
      renderBuffer->setPersistent();
    }
 
    renderBuffer->parameters = r.parameters;
 
    for (auto & p : r.parameters) {
      auto name = r.name + "." + p.key;
      addVariable(expressionContext, name, p);
 
      const size_t code = StringView(p.key).hash();
      switch (code) {
      case Cogs::hash("elementSize"):
      case Cogs::hash("stride"):
        readSize_t(renderBuffer->elementSize, expressionContext, r.name, p);
        break;
      case Cogs::hash("elementCount"):
        readSize_t(renderBuffer->elementCount, expressionContext, r.name, p);
        break;
      case Cogs::hash("bufferSize"):
        readSize_t(renderBuffer->bufferSize, expressionContext, r.name, p);
        break;
      case Cogs::hash("bufferCount"):
        readSize_t(renderBuffer->bufferCount, expressionContext, r.name, p);
        break;
      default:
        break;
      }
    }
 
    return renderBuffer;
  }
 
  RenderTexture * createRenderTexture(RenderTaskContext * renderContext,
                                      RenderPipeline & pipeline,
                                      RenderTaskResources & pipelineResources,
                                      const std::string & resourceName,
                                      const std::string & prefix,
                                      const RenderResourceDefinition & r,
                                      ExpressionContext * expressionContext)
  {
    auto texture = renderContext->context->textureManager->create();
    texture->setName(resourceName);
    texture->setResident();
 
    pipeline.resourceHandles.push_back(texture);
 
    auto renderTexture = renderContext->resources->createRenderTexture();
    texture->attachResource(renderTexture);
 
    renderTexture->setName(resourceName);
    renderTexture->setResource(texture.resolve());
 
    if (r.getParameter("persistent", false)) {
      renderTexture->setPersistent();
    }
    renderTexture->setOwned();
 
    auto format = r.getParameter("format", "R8G8B8A8_UNORM_SRGB");
    renderTexture->description.format = parseTextureFormat(format ? format->value : "R8G8B8A8_UNORM_SRGB");
    renderTexture->description.flags = TextureFlags::Texture | ((r.getParameter("flags", "") != nullptr) ? TextureFlags::DepthBuffer : TextureFlags::RenderTarget);
    renderTexture->description.samples = r.getParameter("samples", 1);
 
    expressionContext->add(r.name + ".width", 0.0);
    expressionContext->add(r.name + ".height", 0.0);
 
    renderTexture->width = { expressionContext, r.name + ".width", std::to_string(renderTexture->width.get(0)), 0 };
    renderTexture->height = { expressionContext, r.name + ".height", std::to_string(renderTexture->height.get(0)), 0 };
 
    for (auto& p : r.parameters) {
      const size_t code = StringView(p.key).hash();
      switch (code) {
 
      case Cogs::hash("clearColor"):
        // Set clear color
        switch (p.type) {
        case ParsedDataType::Int4:
          for (glm::length_t i = 0; i < 4; i++) { renderTexture->clearColor[i] = static_cast<float>(p.int4Value[i]); }
          renderTexture->clearColorSet = true;
          break;
        case ParsedDataType::UInt4:
          for (glm::length_t i = 0; i < 4; i++) { renderTexture->clearColor[i] = static_cast<float>(p.uint4Value[i]); }
          renderTexture->clearColorSet = true;
          break;
        case ParsedDataType::Float4:
          for (glm::length_t i = 0; i < 4; i++) { renderTexture->clearColor[i] = p.float4Value[i]; }
          renderTexture->clearColorSet = true;
          break;
        default:
          LOG_ERROR(logger, "Texture clear color was not a 4-component vector of int nor floats");
          break;
        }
        break;
 
      default: {
 
        // Add as variable
        std::string name = r.name + "." + p.key;
        addVariable(expressionContext, name, p);
        switch (code) {
        case Cogs::hash("width"):
          readSize_t(renderTexture->width, expressionContext, r.name, p);
          break;
        case Cogs::hash("height"):
          readSize_t(renderTexture->height, expressionContext, r.name, p);
          break;
        case Cogs::hash("levels"):
          readSize_t(renderTexture->levels, expressionContext, r.name, p);
          break;
        case Cogs::hash("layers"):
          readSize_t(renderTexture->layers, expressionContext, r.name, p);
          break;
        case Cogs::hash("faces"):
          readSize_t(renderTexture->faces, expressionContext, r.name, p);
          break;
        case Cogs::hash("samples"):
          readSize_t(renderTexture->samples, expressionContext, r.name, p);
          break;
        case Cogs::hash("sizeSource"):
          renderTexture->sizeSource = pipelineResources.get(prefix + p.value)->resource;
          break;
        default:
          break;
        }
      }
      }
    }
 
    return renderTexture;
  }
 
  bool handleResourceAlias(const RenderResourceDefinition & r, const std::string & resourceName, const std::string & prefix, RenderTaskResources & pipelineResources)
  {
    if (r.alias.size()) {
      auto aliasedResource = pipelineResources.get(prefix + r.alias);
 
      if (aliasedResource) {
        pipelineResources.add(aliasedResource, resourceName);
      } else {
        if (r.type != RenderResourceType::RenderTarget) {
          LOG_ERROR(logger, "Error aliasing resource %s to %s.", r.name.c_str(), resourceName.c_str());
        }
      }
 
      return true;
    }
 
    return false;
  }
 
  bool createPipelineRecursive(Cogs::Core::RenderTaskContext * renderContext,
                               const Cogs::Core::RenderPipelineDefinition & pipelineDefinition,
                               Cogs::Core::RenderTaskResources & pipelineResources,
                               Cogs::Core::RenderPipeline & pipeline,
                               const Cogs::Core::PipelineOptions & options,
                               Cogs::Core::ExpressionContext* expressionContext,
                               const std::vector<ParsedValue>& attributes,
                               const std::string & prefix,
                               const std::string & prefixOuter)
  {
    pipelineResources.resources.reserve(100);
 
    auto globalResources = pipelineResources;
 
    for (auto & option : pipelineDefinition.options) {
      pipeline.dependsVariables.push_back(option.setting);
    }
 
//    auto * expressionContext = &pipeline.expressionContext;
    if (!pipelineDefinition.useVariables.empty()
        || !pipelineDefinition.setVariables.empty()
        || !pipelineDefinition.useComponentFields.empty()) {
      pipeline.subContexts.push_back(std::make_unique<SubContext>(expressionContext));
      expressionContext = &pipeline.subContexts.back()->expressionContext;
 
      for (auto & r : pipelineDefinition.inputs) {
        auto resource = pipelineResources.get(prefix + r.key);
 
        if (resource->type == RenderResourceType::RenderTexture || resource->type == RenderResourceType::RenderTarget) {
          // Try to figure out prefix-less name in outer-scope.
          const auto preStrip = prefixOuter.length();
          StringView nameOuter = resource->name;
          if (preStrip <= nameOuter.length() && nameOuter.substr(0, preStrip).compare(prefixOuter) == 0) {
            nameOuter = nameOuter.substr(preStrip);
          }
 
          if (resource->type == RenderResourceType::RenderTexture || nameOuter == "Cogs.BackBuffer") {
            expressionContext->link(expressionContext, nameOuter.to_string() + ".width", r.key + ".width");
            expressionContext->link(expressionContext, nameOuter.to_string() + ".height", r.key + ".height");
          }
        }
      }
 
      pipeline.subContexts.back()->useVariables(renderContext->context, pipelineDefinition.useVariables);
      pipeline.subContexts.back()->setVariables(renderContext->context, pipelineDefinition.setVariables);
      pipeline.subContexts.back()->useComponentFields(renderContext, pipelineDefinition.useComponentFields);
    }
 
    for (auto & r : pipelineDefinition.resources) {
      auto resourceName = prefix + r.name;
 
      if (!evaluateCondition(renderContext->context, r.condition, pipelineDefinition, attributes)) continue;
 
      if (handleResourceAlias(r, resourceName, prefix, pipelineResources)) continue;
 
      switch (r.type) {
      case RenderResourceType::RenderBuffer:
      {
        auto renderBuffer = createRenderBuffer(renderContext->resources, resourceName, r, expressionContext);
 
        pipelineResources.add(renderBuffer, resourceName);
        pipeline.resources.add(renderBuffer, resourceName);
      }
      break;
      case RenderResourceType::RenderList:
      {
        auto renderList = renderContext->resources->createRenderList();
        renderList->setName(resourceName);
 
        pipelineResources.add(renderList, resourceName);
        pipeline.resources.add(renderList, resourceName);
      }
      break;
      case RenderResourceType::RenderTexture:
      {
        auto renderTexture = createRenderTexture(renderContext, pipeline, pipelineResources, resourceName, prefix, r, expressionContext);
 
        pipelineResources.add(renderTexture, resourceName);
        pipeline.resources.add(renderTexture, resourceName);
      }
      break;
      default:
        break;
      }
    }
 
    for (auto & r : pipelineDefinition.resources) {
      auto resourceName = prefix + r.name;
 
      if (!evaluateCondition(renderContext->context, r.condition, pipelineDefinition, attributes)) continue;
 
      if (handleResourceAlias(r, resourceName, prefix, pipelineResources)) continue;
 
      if (r.type == RenderResourceType::RenderTarget) {
        auto renderTarget = renderContext->resources->createRenderTarget();
        renderTarget->setName(resourceName);
 
        auto depth = r.getParameter("depth", "");
        if (depth) {
          auto depthTexture = pipelineResources.get(prefix + depth->value);
 
          if (!depthTexture) {
            auto format = parseTextureFormat(depth->value);
 
            if (format != TextureFormat::Unknown) {
              auto depthName = resourceName + ":DepthTexture";
              auto depth_rtex = renderContext->resources->createRenderTexture();
              depth_rtex->setName(depthName);
              depth_rtex->description.flags = TextureFlags::DepthBuffer | TextureFlags::Texture;
              depth_rtex->description.format = format;
 
              renderTarget->depth = depth_rtex;
 
              pipelineResources.add(depth_rtex, depthName);
              pipeline.resources.add(depth_rtex, depthName);
            }
          } else {
            renderTarget->depth = depthTexture->renderTexure;
          }
        }
 
        auto clearColor = r.getParameter("clearColor", "");
        if (clearColor && clearColor->type == ParsedDataType::Float4) {
          renderTarget->clearColors = { clearColor->float4Value };
        }
 
        auto levels = r.getParameter("levels", "");
        if (levels) {
          readSize_t(renderTarget->levels, expressionContext, r.name + std::to_string((size_t)renderTarget), *levels);
        }
 
        size_t textureIndex = 0;
        for (auto & t : r.textures) {
          auto name = prefix + t;
          auto textureResource = pipelineResources.get(name);
 
          if (textureResource) {
            renderTarget->textures.push_back(textureResource->renderTexure);
          } else {
            auto format = parseTextureFormat(t);
 
            if (format != TextureFormat::Unknown) {
              auto textureName = resourceName + ":Texture" + std::to_string(textureIndex++);
 
              auto texture = renderContext->resources->createRenderTexture();
              texture->setName(textureName);
              texture->description.format = format;
              texture->description.flags = TextureFlags::Texture | TextureFlags::RenderTarget;
 
              renderTarget->textures.push_back(texture);
 
              pipelineResources.add(texture, textureName);
              pipeline.resources.add(texture, textureName);
            } else {
              LOG_ERROR(logger, "Could not resolve resource %s.", name.c_str());
            }
          }
        }
 
        pipelineResources.add(renderTarget, resourceName);
        pipeline.resources.add(renderTarget, resourceName);
      }
    }
 
    std::list<RenderTask *> tasks;
 
    for (auto & t : pipelineDefinition.tasks) {
      if (!evaluateCondition(renderContext->context, t.condition, pipelineDefinition, attributes)) continue;
 
      if (t.type[0] == '$') {
        bool found = false;
 
        for (auto & p : renderContext->renderer->getPipelineManager()->nameMap) {
          if (p.first == t.type.substr(1)) {
            auto & g = renderContext->renderer->getPipelineManager()->definitionByKey(renderContext->context, p.second);
 
            auto gPrefix = prefix + t.name;
 
            PipelineOptions gOptions;
 
            for (auto & o : t.options) {
              gOptions.push_back({ o.key, o.value });
            }
 
            RenderTaskResources gResources;
            for (size_t i = 0; i < 2; ++i) {
              gResources.add(&pipelineResources.resources[i]);
            }
 
            for (auto & input : g.inputs) {
              bool handled = false;
              for (auto & ii : t.inputs) {
                if (ii.key == input.key) {
                  const auto resourceName = prefix + ii.value;
                  if (auto * resource = pipelineResources.get(resourceName); resource) {
                    gResources.add(resource, gPrefix + input.key);
                    handled = true;
                  } else {
                    LOG_ERROR(logger, "In task %s.%s, failed to find input resource '%s'.", pipelineDefinition.name.c_str(), t.name.c_str(), resourceName.c_str());
                    goto bail;
                  }
                }
              }
              if (!handled) {
                LOG_ERROR(logger, "In task %s.%s, un-matched input key '%s'", pipelineDefinition.name.c_str(), t.name.c_str(), input.key.c_str());
                goto bail;
              }
            }
 
            for (auto & output : g.outputs) {
              bool handled = false;
              for (auto & oo : t.outputs) {
 
                if ((g.outputs.size() == 1 && t.outputs.size() == 1 && oo.key.empty())
                    || (oo.key == output.key)) {
                  const auto resourceName = prefix + oo.value;
                  if (auto * resource = pipelineResources.get(resourceName); resource) {
                    gResources.add(resource, gPrefix + output.key);
                    handled = true;
                  } else {
                    LOG_ERROR(logger, "In task %s.%s, failed to find output resource '%s'.", pipelineDefinition.name.c_str(), t.name.c_str(), resourceName.c_str());
                    goto bail;
                  }
                } else {
                  LOG_WARNING(logger, "In task %s.%s, unhandled output key='%s', value='%s'", pipelineDefinition.name.c_str(), t.name.c_str(), oo.key.c_str(), oo.value.c_str());
                }
              }
              if (!handled) {
                LOG_ERROR(logger, "In task %s.%s, un-matched output key '%s'", pipelineDefinition.name.c_str(), t.name.c_str(), output.key.c_str());
                goto bail;
              }
 
            }
 
            createPipelineRecursive(renderContext, g, gResources, pipeline, gOptions, expressionContext, attributes, gPrefix, prefix);
 
            for (auto tt : pipeline.tasks) {
              tasks.push_back(tt);
            }
 
          bail:
            pipeline.tasks.clear();
 
            found = true;
            break;
          }
        }
        if (!found)
          LOG_ERROR(logger, "Failed to resolve pipeline type '%s'", t.type.c_str());
        continue;
      }
 
      auto tt = t;
      tt.name = prefix + tt.name;
 
      auto task = createRenderTask(renderContext, tt, pipeline.subContexts, expressionContext, options);
 
      if (!task) {
        LOG_ERROR(logger, "Pipeline task chain incomplete.");
        return false;
      }
 
      task->name = tt.name;
      for (auto & d : t.dependencies) {
        auto dependencyName = prefix + d;
 
        auto r = pipelineResources.get(dependencyName);
 
        if (r != nullptr) {
          task->dependencies.push_back(r->name);
        } else {
          task->dependencies.push_back(prefix + d);
        }
      }
 
      for (auto & input : t.inputs) {
        const std::string resourceName = prefix + input.value;
        if (RenderTaskResource* resource = pipelineResources.get(resourceName); resource) {
          if (!input.key.empty()) {
            task->input.add(pipelineResources.get(prefix + input.value), input.key);
          }
          else {
            task->input.add(pipelineResources.get(prefix + input.value), input.value);
          }
        }
        else {
          LOG_ERROR(logger, "Unknown pipeline resource '%s'", resourceName.c_str());
          return false;
        }
      }
 
      for (auto & output : t.outputs) {
        if (output.key.size()) {
          task->output.add(pipelineResources.get(prefix + output.value), output.key);
        } else {
          task->output.add(pipelineResources.get(prefix + output.value), output.value);
        }
      }
 
      tasks.push_back(task);
    }
 
    if (prefix.size()) {
      for (auto t : tasks) {
        pipeline.tasks.push_back(t);
      }
 
      return true;
    }
 
    evaluateTaskDependencies(tasks, globalResources, pipeline);
 
    return true;
  }
 
 
  size_t pipelineHash(RenderTaskContext * renderContext, const RenderPipeline & pipeline)
  {
    size_t hashValue = Cogs::hash();
 
    for (const std::string& vars : pipeline.dependsVariables) {
      hashValue = hash(renderContext->context->variables->get(vars, StringView()), hashValue);
    }
    return hashValue;
  }
}
 
bool Cogs::Core::createPipeline(RenderTaskContext * renderContext,
                                const RenderPipelineDefinition & pipelineDefinition,
                                RenderTaskResources & pipelineResources,
                                RenderPipeline & pipeline,
                                const StringView & path,  // used to pull query-part as options.
                                const CameraData* cameraData,
                                const PipelineOptions & options,
                                const std::string & prefix)
{
 
  pipeline.expressionContext.clear();
  pipeline.expressionContext.inherit(renderContext->expressionContext);
 
  std::vector<ParsedValue> attributes;
  auto queryLoc = path.find("?");
  if (queryLoc != StringView::NoPosition) {
    parseQueryString(attributes, path.substr(queryLoc + 1));
  }
 
  const CameraData* cameraDataSaved = renderContext->cameraData;
  if (cameraData) {
    renderContext->cameraData = cameraData;
  }
 
  ExpressionContext* expressionContextSave = renderContext->expressionContext;
  renderContext->expressionContext = &pipeline.expressionContext;
 
  bool rv = false;
  if (createPipelineRecursive(renderContext, pipelineDefinition, pipelineResources, pipeline, options, &pipeline.expressionContext, attributes, prefix, "")) {
    pipeline.dependsVariables.sort();
    pipeline.dependsVariables.unique();
    pipeline.hash = pipelineHash(renderContext, pipeline);
    rv = true;
  }
 
  renderContext->expressionContext = expressionContextSave;
  renderContext->cameraData = cameraDataSaved;
  return rv;
}
 
bool Cogs::Core::isPipelineFresh(RenderTaskContext * renderContext, const RenderPipeline & pipeline)
{
  return pipeline.hash == pipelineHash(renderContext, pipeline);
}
 
void Cogs::Core::releasePipeline(RenderTaskContext * renderContext, RenderPipeline & pipeline)
{
  for (auto & r : pipeline.resources.resources) {
    if (!r.resource->isOwned()) {
      renderContext->resources->releaseResource(r.resource);
      renderContext->resources->destroyResource(r.resource);
    } else {
      renderContext->resources->releaseResource(r.resource);
    }
  }
 
  pipeline.resources.resources.clear();
  pipeline.resourceHandles.clear();
 
  freeTasks(pipeline.tasks, renderContext);
  pipeline.tasks.clear();
 
  pipeline.subContexts.clear();
  pipeline.expressionContext.clear();
  pipeline.dependsVariables.clear();
}