RenderPipelineManager.cpp

#include <string>
 
#include "RenderPipelineManager.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/CameraArraySystem.h"
 
#include "Services/Time.h"
#include "Services/Services.h"
#include "Services/PipelineService.h"
 
#include "Context.h"
#include "ViewContext.h"
 
#include "Renderer.h"
#include "RenderPipelineFactory.h"
#include "RenderTexture.h"
#include "RenderTarget.h"
#include "RenderList.h"
 
#include "Serialization/RenderPipelineReader.h"
 
#include "Tasks/RenderTaskFactory.h"
#include "Tasks/RenderListTask.h"
#include "Tasks/ReadbackTask.h"
 
#include "Rendering/ICapabilities.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Collections/SmallVector.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Platform/Mouse.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
namespace
{
  using namespace Cogs::Core;
  using Cogs::Collections::SmallVector;
  using PipeInitFunc = std::function<void(PipelineInstance* instance, RenderTaskResources& resources, bool wasCreated)>;
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderPipelineManager");
 
  const std::string forwardPath = "Pipelines/Forward.pipeline";
  const std::string shadowPath = "Pipelines/Shadow.pipeline";
 
  std::string toHexString(size_t value)
  {
    constexpr size_t maxDigits = 2 * sizeof(size_t);
    static const char digits[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
    std::string rv;
 
    rv.reserve(2 + maxDigits);
    rv.push_back('0');
    rv.push_back('x');
    size_t o = maxDigits;
    while (o) {
      if (size_t nibble = (value >> (4 * (o - 1)) & 0xF); nibble) {
        break;
      }
      o--;
    }
    while (o) {
      size_t nibble = (value >> (4 * (o - 1)) & 0xF);
      rv.push_back(digits[nibble]);
      o--;
    }
    return rv;
  }
 
   RenderTexture* getRenderTexture(RenderTaskContext* renderContext, size_t& dataHash, const TextureHandle& texture, const Cogs::StringView& name, bool useAsTarget)
   {
     if (!texture) return nullptr;
 
     RenderTexture* renderTexture = renderContext->resources->getRenderTexture(texture); 
     if (renderTexture) {
       if (useAsTarget && !renderTexture->renderTarget) {
 
         assert(!renderTexture->depthTexture);
         RenderTexture* depthTexture = renderContext->resources->createRenderTexture();
         depthTexture->setName(name.to_string() + " DT");
         depthTexture->description.target = (renderTexture->description.samples > 1) ? Cogs::ResourceDimensions::Texture2DMS : Cogs::ResourceDimensions::Texture2D;
         depthTexture->description.flags = Cogs::TextureFlags::DepthBuffer;
         depthTexture->description.format = Cogs::TextureFormat::R32_TYPELESS;
         depthTexture->description.samples = renderTexture->description.samples;
         depthTexture->sizeSource = renderTexture;
         renderTexture->depthTexture = depthTexture;
 
         assert(!renderTexture->renderTarget);
         RenderTarget* renderTarget = renderContext->resources->createRenderTarget();
         renderTarget->setName(name.to_string() + " RT");
         renderTarget->textures.push_back(renderTexture);
         renderTarget->depth = depthTexture;
         renderTarget->width = renderTexture->description.width;
         renderTarget->height = renderTexture->description.height;
         renderTarget->samples = renderTexture->description.samples;
         renderTexture->renderTarget = renderTarget;
       }
       dataHash = Cogs::hashSequence(dataHash,
                                     reinterpret_cast<intptr_t>(renderTexture),
                                     reinterpret_cast<intptr_t>(renderTexture->renderTarget),
                                     reinterpret_cast<intptr_t>(renderTexture->depthTexture));
     }
 
     return renderTexture;
   }
 
   void releasePipelineInstance(RenderTaskContext* renderContext, PipelineInstance* instance)
   {
     releasePipeline(renderContext, instance->pipeline);
     instance->options.clear();
     instance->dataHash = 0;
     instance->priority = 0;
     instance->pipeline.updateResources.resources.clear();
   }
 
   bool setupCameraPipeline(RenderTaskContext* renderContext, RenderPipelineManager* manager,
                            size_t instanceKey, size_t dataHash, const Cogs::StringView& pipeline, int priority,
                            PipeInitFunc const& initFunc, const CameraComponent* camComp, const CameraData* camData, RenderTexture* renderTexture, RenderList* renderList)
   {
     auto [instance, wasCreated] = manager->instanceByKey(renderContext->context, instanceKey);
     if (wasCreated) {
       instance->priority = priority;
       instance->sanityCheck = camData;
     }
     assert(instance->sanityCheck == camData);
 
     dataHash = Cogs::hash(pipeline, dataHash);
     if (camComp) {
       for (const std::string& value : camComp->renderPipelineOptions) {
         dataHash = Cogs::hash(value, dataHash);
       }
     }
 
     if (wasCreated || instance->dataHash != dataHash || instance->priority != priority || !isPipelineFresh(renderContext, instance->pipeline)) {
       releasePipelineInstance(renderContext, instance);
       instance->dataHash = dataHash;
       instance->priority = priority;
 
       RenderTaskResources resources;
       for (RenderTaskResource& resource : manager->globalResources.resources) {
         resources.add(&resource);
       }
       if (renderList) {
         resources.add(renderList, "Cogs.RenderList");
       }
       if (camComp) {
         for (size_t i = 0, n = camComp->renderPipelineOptions.size() / 2; i < n; i++) {
           instance->options.push_back({
             camComp->renderPipelineOptions[2 * i + 0],
             camComp->renderPipelineOptions[2 * i + 1]
           });
         }
       }
 
       if (renderTexture) {
         instance->pipeline.updateResources.add(renderTexture->depthTexture);
         instance->pipeline.updateResources.add(renderTexture->renderTarget);
         resources.add(renderTexture->renderTarget, "Cogs.BackBuffer");
 
         ExpressionContext& expressionContext = instance->pipeline.expressionContext;
 
         expressionContext.add("Cogs.BackBuffer.width", renderTexture->description.width);
         expressionContext.add("Cogs.BackBuffer.height", renderTexture->description.height);
 
         renderTexture->width = { &expressionContext, "Cogs.BackBuffer.width", std::to_string(renderTexture->description.width), 0 };
         renderTexture->height = { &expressionContext, "Cogs.BackBuffer.height", std::to_string(renderTexture->description.height), 0 };
 
         instance->options.push_back({ "Pass", "Offscreen" });
       }
       instance->renderTarget = renderTexture;
 
       if (initFunc) {
         initFunc(instance, resources, wasCreated);
       }
 
       const RenderPipelineDefinition& pipeDefinition = manager->definitionByPath(renderContext->context, pipeline);
       createPipeline(renderContext, pipeDefinition, resources, instance->pipeline, pipeline, camData, instance->options);
 
       return true;
     }
     return true;
   }
 
 
  void setupLightPipeline(RenderTaskContext * renderContext,
                          Cogs::Core::RenderPipelineManager* manager,
                          LightComponent& light,
                          const LightData& lightData,
                          TextureHandle shadowTexture,
                          RenderList * renderList)
  {
    auto [instance, wasCreated] = manager->instanceByKey(renderContext->context, Cogs::hashSequence(Cogs::hash("Light"), light.hash()));
    if (wasCreated) {
      instance->name = "Light@" + toHexString(size_t(&light));
      instance->priority = 100;
      instance->sanityCheck = &light;
      LOG_DEBUG(logger, "Added light pipeline");
    }
    assert(instance->sanityCheck == &light);
 
    auto renderTexture = renderContext->resources->getRenderTexture(shadowTexture);
    if (!renderTexture) return;
 
    size_t dataHash = Cogs::hash(reinterpret_cast<intptr_t>(renderTexture));
 
    // Set up shadow map render target
    // -------------------------------
 
    // Light texture is either array texture (directional light) or cube map texture (point light)
    for (uint32_t i = 0; i < lightData.maxViewports; ++i) {
      const uint32_t arrayIndex = i + lightData.arrayOffset;
      if (!(arrayIndex < renderTexture->renderTargets.size())) {
        LOG_ERROR(logger, "Light shadow arrayIndex larger than renderTarget size");
        return;
      }
      if (!renderTexture->renderTargets[arrayIndex]) {
        auto renderTarget = renderContext->resources->createRenderTarget();
        renderTarget->setName("Light 0x" + toHexString(size_t(&light)) + " RT arrayIndex=" + std::to_string(arrayIndex));
        renderTarget->depth = renderTexture;
        renderTarget->depthLayerIndex = arrayIndex;
        renderTexture->renderTargets[arrayIndex] = renderTarget;
      }
      dataHash = Cogs::hashSequence(reinterpret_cast<intptr_t>(renderTexture->renderTargets[arrayIndex]), dataHash);
    }
    dataHash = Cogs::hashSequence(lightData.shadowUpdate, dataHash);
 
    // Set up shadow map render pipline
    // --------------------------------
 
    if (wasCreated || instance->dataHash != dataHash || !isPipelineFresh(renderContext, instance->pipeline)) {
      releasePipelineInstance(renderContext, instance);
      instance->dataHash = dataHash;
 
      for (size_t viewportIndex = 0; viewportIndex < lightData.maxViewports; viewportIndex++) {
        const size_t arrayIndex = viewportIndex + lightData.arrayOffset;
 
        instance->pipeline.updateResources.add(renderTexture->renderTargets[arrayIndex]);
 
        RenderTaskResources resources;
        resources.add(renderTexture->renderTargets[arrayIndex], "Cogs.BackBuffer");
        resources.add(renderList, "Cogs.RenderList");
 
        createPipeline(renderContext, manager->definitionByPath(renderContext->context, shadowPath), resources, instance->pipeline, shadowPath, &lightData.lightCameraData[viewportIndex], instance->options);
 
        for (size_t taskIndex = viewportIndex * 2; taskIndex < viewportIndex * 2 + 2; ++taskIndex) {
          instance->pipeline.tasks[taskIndex]->frameMod = 0;// lightData.frameMod[viewportIndex];
          instance->pipeline.tasks[taskIndex]->frameOffset = 0;// lightData.frameOffset[viewportIndex];
          if (lightData.shadowUpdate == ShadowUpdate::Static || lightData.shadowUpdate == ShadowUpdate::StaticPartial) {
            instance->pipeline.tasks[taskIndex]->flags = (RenderTaskFlags::ERenderTaskFlags)((int)instance->pipeline.tasks[taskIndex]->flags | (int)RenderTaskFlags::Static);
          }
        }
      }
      if (!wasCreated) LOG_DEBUG(logger, "Updated light pipeline");
      manager->dirty = true;
    }
  }
 
  void setupAuxPipelines(RenderTaskContext * renderContext, RenderPipelineManager* manager, RenderList* renderList)
  {
    std::vector<const Variable*> vars;
    renderContext->context->variables->getMatchingVariables(vars, "renderer.auxiliaryPipelines.");
 
    for (const auto * var : vars) {
      if (var->getValue().empty()) continue;
 
      std::vector<Cogs::StringView> tokens;
      split(var->getValue(), ":", tokens);
      if (tokens.empty() || 2 < tokens.size()) {
        LOG_ERROR_ONCE(logger, "Failed to tokenize %.*s: '%.*s'", StringViewFormat(var->getName()), StringViewFormat(var->getValue()));
        continue;
      }
 
      size_t dataHash = 0;
      size_t instanceKey = Cogs::hashSequence(Cogs::hash("AuxPipeline"), var->getName().hash());
      Cogs::StringView pipeline = tokens[0];
      int priority = 0;
      if (1 < tokens.size()) {
        priority = std::stoi(tokens[1].to_string());
      }
 
      PipeInitFunc initFunc = [var, &pipeline](PipelineInstance* instance, RenderTaskResources& /*resources*/, bool wasCreated)
      {
        instance->name = var->getName().to_string();
        instance->options.push_back( { "Pass", "Offscreen" });
        LOG_DEBUG(logger, "%s aux pipeline run for %s: %.*s", wasCreated ? "Creating" : "Updating", instance->name.c_str(), StringViewFormat(pipeline));
      };
 
      setupCameraPipeline(renderContext, manager,
                          instanceKey, dataHash, pipeline, priority,
                          initFunc, nullptr, nullptr, nullptr, renderList);
    }
  }
 
  void setupExtraPipelineRuns(RenderTaskContext * renderContext, RenderPipelineManager* manager, RenderList* renderList)
  {
    PipelineService* pipelineService = renderContext->context->services->getService<PipelineService>();
    for (PipelineRun* run : pipelineService->runs) {
      if (run->enabled && !run->pipeline.empty()) {
 
        size_t dataHash = 0;
        size_t instanceKey = Cogs::hashSequence(run->name.hash(),  reinterpret_cast<intptr_t>(run->cameraData));
        RenderTexture* renderTexture = nullptr;
        if (run->renderTexture) {
          renderTexture = getRenderTexture(renderContext, dataHash, run->renderTexture, run->name, true);
        }
 
        PipeInitFunc initFunc = [run, renderTexture, renderContext](PipelineInstance* instance, RenderTaskResources& resources, bool wasCreated)
        {
          instance->name = run->name.to_string();
          instance->options.push_back( { "Pass", "Offscreen" });
          if (!renderTexture) {
            resources.add(renderContext->defaultRenderTarget, "Cogs.BackBuffer");
            instance->options.push_back({ "Pass", "Onscreen" });
          }
          LOG_DEBUG(logger, "%s extra pipeline run for %s: %s", wasCreated ? "Creating" : "Updating", instance->name.c_str(), run->pipeline.c_str());
        };
 
        setupCameraPipeline(renderContext, manager,
                            instanceKey, dataHash, run->pipeline, run->priority,
                            initFunc, nullptr, run->cameraData, renderTexture, renderList);
      }
    }
  }
 
  void setupLightPipelines(RenderTaskContext * renderContext, RenderPipelineManager* manager, RenderList* renderList)
  {
    for (auto & light : renderContext->context->lightSystem->pool) {
      auto & lightData = renderContext->context->lightSystem->getData(&light);
 
      if (!lightData.enabled || !lightData.castShadows) continue;
 
      setupLightPipeline(renderContext, manager, light, lightData, lightData.shadowTexture, renderList);
    }
  }
 
  void setupCameraArrayRenderTarget(RenderTaskContext* renderContext,
                                             size_t& dataHash, RenderTexture* renderTexture, size_t targetIndex,
                                             uint32_t multiViewCount, uint32_t multiViewSamples,
                                             const CameraArrayComponent& camArrComp, CameraArrayData& camArrData,
                                             const Cogs::StringView name)
  {
    if (1 < multiViewCount) {
      camArrData.passOptions = camArrData.camData.passOptions ? *camArrData.camData.passOptions : RenderPassOptions{};
      camArrData.camData.passOptions = &camArrData.passOptions;
      camArrData.passOptions.multiViews = multiViewCount;
    }
 
    if (!renderTexture->renderTargets[targetIndex]) {
      RenderTarget* renderTarget = renderContext->resources->createRenderTarget();
      renderTarget->setName(name.to_string() + " MV-RT[" + std::to_string(targetIndex) + ":" + std::to_string(multiViewCount) + "]");
      renderTarget->textures.push_back(renderTexture);
      renderTarget->layerIndex = uint16_t(targetIndex);
      renderTarget->depth = renderTexture->depthTexture;
      renderTarget->depthLayerIndex = uint16_t(targetIndex);
      if (1 < multiViewCount) {
        renderTarget->multiViewBaseIndex = 0;
        renderTarget->multiViewCount = static_cast<uint8_t>(multiViewCount);
        renderTarget->multiViewSamples = static_cast<uint8_t>(std::min(255u, multiViewSamples));
      }
      renderTarget->width = renderTexture->description.width;
      renderTarget->height = renderTexture->description.height;
      renderTarget->samples = renderTexture->description.samples;
      renderTarget->expectsSRGB = camArrComp.expectsSRGB;
      renderTexture->renderTargets[targetIndex] = renderTarget;
    }
    dataHash = Cogs::hashSequence(dataHash, reinterpret_cast<intptr_t>(renderTexture->renderTarget));
  }
 
  void setupCameraArrayDepthTarget(RenderTaskContext* renderContext,
                                   size_t& dataHash, RenderTexture* renderTexture, size_t targetIndex,
                                   const CameraArrayData& camArrData, const Cogs::StringView name)
  {
    switch (camArrData.depthMode) {
 
    case CameraArrayData::DepthMode::None:
      break;
 
    case CameraArrayData::DepthMode::Create:
      if (!renderTexture->depthTexture) {
        RenderTexture* depthTexture = renderContext->resources->createRenderTexture();
        depthTexture->setName(name.to_string() + " DT");
        depthTexture->description.target = renderTexture->description.target;
        depthTexture->description.flags = Cogs::TextureFlags::DepthBuffer;
        depthTexture->description.format = Cogs::TextureFormat::R32_TYPELESS;
        depthTexture->layers = renderTexture->description.layers;
        depthTexture->samples = renderTexture->description.samples;
        depthTexture->sizeSource = renderTexture;
        renderTexture->depthTexture = depthTexture;
      }
      dataHash = Cogs::hashSequence(dataHash, reinterpret_cast<intptr_t>(renderTexture->depthTexture));
      break;
 
    case CameraArrayData::DepthMode::Provided:
      if (!renderTexture->depthTexture) {
        renderTexture->depthTexture = getRenderTexture(renderContext, dataHash, camArrData.depthTextures[targetIndex], name, false);
      }
      dataHash = Cogs::hashSequence(dataHash, reinterpret_cast<intptr_t>(renderTexture->depthTexture));
      break;
 
    default:
      assert(false && "Illegal enum");
      break;
    }
  }
 
  void setupCameraArrayDraw(RenderTaskContext* renderContext, RenderPipelineManager* manager, RenderList* renderList,
                            const size_t dataHash, RenderTexture* renderTexture, size_t targetIndex,
                            const CameraArrayData& camArrData, const CameraComponent& camComp,
                            const Cogs::StringView name, size_t instanceKey)
  {
    Cogs::StringView pipeline = camArrData.pipeline.empty() ? forwardPath : camArrData.pipeline;
 
    PipeInitFunc initFunc = [targetIndex, &name, &pipeline, renderTexture, updateDepth = camArrData.depthMode == CameraArrayData::DepthMode::Create](PipelineInstance* instance, RenderTaskResources& resources, bool wasCreated)
      {
        instance->name = name.to_string();
        // Update the resources owned by this pipeline
        if (updateDepth) {
          instance->pipeline.updateResources.add(renderTexture->depthTexture);
        }
        instance->pipeline.updateResources.add(renderTexture->renderTargets[targetIndex]);
        resources.add(renderTexture->renderTargets[targetIndex], "Cogs.BackBuffer");
 
        ExpressionContext& expressionContext = instance->pipeline.expressionContext;
 
        expressionContext.add("Cogs.BackBuffer.width", renderTexture->description.width);
        expressionContext.add("Cogs.BackBuffer.height", renderTexture->description.height);
 
        //renderTexture->width = { &expressionContext, "Cogs.BackBuffer.width", std::to_string(renderTexture->description.width), 0 };
        //renderTexture->height = { &expressionContext, "Cogs.BackBuffer.height", std::to_string(renderTexture->description.height), 0 };
 
        LOG_DEBUG(logger, "%s offscreen camera pipeline for %s: %.*s", wasCreated ? "Creating" : "Updating", instance->name.c_str(), StringViewFormat(pipeline));
      };
 
    setupCameraPipeline(renderContext, manager,
                        Cogs::hashSequence(instanceKey, targetIndex), dataHash, pipeline, 300 + camComp.stackOrder,
                        initFunc, &camComp, &camArrData.camData, nullptr, renderList);
 
  }
 
 
  void setupCameraArrayPipelines(RenderTaskContext* renderContext, RenderPipelineManager* manager, RenderList* renderList)
  {
    bool multiView = renderContext->device->getCapabilities()->getDeviceCapabilities().MultiView;
 
    std::string name_;
 
    for (const CameraArrayComponent& camArrComp : renderContext->context->cameraArraySystem->pool) {
 
      CameraArrayData& camArrData = renderContext->context->cameraArraySystem->getData(&camArrComp);
      if (camArrData.textureMode == CameraArrayData::TextureMode::None) {
        continue;
      }
 
      Cogs::StringView name = camArrComp.getContainer()->getName();
      if (name.empty()) {
        const Entity* entity = camArrComp.getContainer();
        name_ = "CameraArray@" + std::to_string(entity->getId());
        name = name_;
      }
 
      assert(camArrData.camData.camera);
      const CameraComponent& camComp = renderContext->context->cameraSystem->pool[camArrData.camData.camera.index];
      size_t instanceKey = Cogs::hashSequence(Cogs::hash("CameraArrays"), reinterpret_cast<intptr_t>(&camArrData.camData));
 
      switch (camArrData.textureMode) {
 
      case  CameraArrayData::TextureMode::TextureArray: {
        size_t dataHash = 0;
        if (RenderTexture* renderTexture = getRenderTexture(renderContext, dataHash, camArrData.colorTextures[0], name, false); renderTexture) {
 
 
          setupCameraArrayDepthTarget(renderContext, dataHash, renderTexture, 0, camArrData, name);
 
 
          if ((1 < renderTexture->description.layers) && multiView) {
            setupCameraArrayRenderTarget(renderContext, dataHash, renderTexture, 0, renderTexture->description.layers, camArrComp.samples, camArrComp, camArrData, name);
            setupCameraArrayDraw(renderContext, manager, renderList, dataHash, renderTexture, 0, camArrData, camComp, name, instanceKey);
          }
 
          else {
            for (size_t l = 0; l < renderTexture->description.layers; l++) {
              setupCameraArrayRenderTarget(renderContext, dataHash, renderTexture, l, 1, 1, camArrComp, camArrData, name);
            }
            for (size_t l = 0; l < renderTexture->description.layers; l++) {
              setupCameraArrayDraw(renderContext, manager, renderList, dataHash, renderTexture, l, camArrData, camComp, name, Cogs::hashSequence(instanceKey, static_cast<intptr_t>(l)));
            }
          }
        }
        break;
      }
 
      case  CameraArrayData::TextureMode::ArrayOfTextures:
        for (size_t l = 0; l < camArrData.numViews; l++) {
          size_t dataHash = 0;
          if (RenderTexture* renderTexture = getRenderTexture(renderContext, dataHash, camArrData.colorTextures[l], name, false); renderTexture) {
            setupCameraArrayDepthTarget(renderContext, dataHash, renderTexture, l, camArrData, name);
            setupCameraArrayRenderTarget(renderContext, dataHash, renderTexture, l, 1, 1, camArrComp, camArrData, name);
            setupCameraArrayDraw(renderContext, manager, renderList, dataHash, renderTexture, l, camArrData, camComp, name, Cogs::hashSequence(instanceKey, static_cast<intptr_t>(l)));
          }
        }
        break;
 
      case  CameraArrayData::TextureMode::None: [[fallthrough]];
      default:
        assert(false && "Illegal enum");
        break;
      }
 
    }
  }
 
  size_t cameraInstanceKey(const CameraData& camData, bool isMainCamera)
  {
    return Cogs::hashSequence(Cogs::hash("Camera"), isMainCamera ? 1 : 0, reinterpret_cast<intptr_t>(&camData));
  }
 
  void setupCameraPipelines(RenderTaskContext * renderContext, RenderPipelineManager* manager, RenderList* renderList)
  {
    std::string nameTemp;
    const bool defaultTargetRender = renderContext->context->variables->get("renderer.defaultTarget.render", true);
 
    const CameraComponent* mainCamComp = renderContext->context->cameraSystem->getMainCamera();
    for(const CameraComponent& camComp : renderContext->context->cameraSystem->pool) {
 
      if ((camComp.flags & CameraFlags::EnableRender) == 0) { continue; }
 
 
      const Entity* entity = camComp.getContainer();
      Cogs::StringView name = entity->getName();
      if (name.empty()) {
        nameTemp = "Camera, entity=" + std::to_string(entity->getId());
        name = nameTemp;
      }
 
      // If offscreen, grab offscreen texture
      size_t dataHash = 0;
      Cogs::StringView pipeline = camComp.renderPipeline.empty() ? forwardPath : camComp.renderPipeline;
      RenderTexture* renderTexture = nullptr;
 
      bool isMainCamera = &camComp == mainCamComp;
      if (isMainCamera) {
 
        // The debug gui use this to override the current pipeline without actually changing it when setting visualization mode
        if (const Variable* var1 = renderContext->context->variables->get("renderer.pipeline.override"); var1 && !var1->isEmpty() && !var1->getValue().empty()) {
          pipeline = var1->getCString();
        }
 
        // Main camera pipeline can be overriden with renderer.pipeline. Should be removed.
        else if (const Variable* var2 = renderContext->context->variables->get("renderer.pipeline"); var2 && !var2->isEmpty() && !var2->getValue().empty()) {
          pipeline = var2->getCString();
        }
 
      }
      else {
        if (camComp.renderTexture) {
          renderTexture = getRenderTexture(renderContext, dataHash, camComp.renderTexture, name, true);
        }
      }
 
      if (renderTexture == nullptr && defaultTargetRender == false) {
        // Rendering to default render target disabled, skip setting up a pipeline.
        continue;
      }
 
      PipeInitFunc initFunc = [&name, &pipeline, renderTexture, renderContext](PipelineInstance* instance, RenderTaskResources& resources, bool wasCreated)
      {
        instance->name = name.to_string();
        if (!renderTexture) {
          resources.add(renderContext->defaultRenderTarget, "Cogs.BackBuffer");
        }
        LOG_DEBUG(logger, "%s main camera pipeline for %s: %.*s", wasCreated ? "Creating" : "Updating", instance->name.c_str(), StringViewFormat(pipeline));
      };
 
      const CameraData& camData = renderContext->context->cameraSystem->getData(&camComp);
      setupCameraPipeline(renderContext, manager,
                          cameraInstanceKey(camData, isMainCamera), dataHash, pipeline, (renderTexture ? 300 : 400) + camComp.stackOrder,
                          initFunc, &camComp, &camData, renderTexture, renderList);
    }
  }
 
}
 
 
 
 
void Cogs::Core::RenderPipelineManager::initialize(RenderTaskContext* renderContext)
{
  renderList = renderContext->resources->createRenderList();
  renderList->setName("Cogs.RenderList");
 
  std::list<std::unique_ptr<SubContext>> subContexts; // dummy for call to createRenderTask, not actually used when creating a GenerateList task.
 
  RenderTaskDefinition taskDefinition = {};
  taskDefinition.name = "Cogs.GenerateList";
  taskDefinition.type = "GenerateList";
  generateListTask = createRenderTask(renderContext, taskDefinition, subContexts, &expressionContextRoot);
  generateListTask->output.add(renderList);
  generateListTask->flags = RenderTaskFlags::Persistent;
}
 
void Cogs::Core::RenderPipelineManager::cleanup(RenderTaskContext* renderContext)
{
  if (!renderList) return;
 
  assert(generateListTask);
  destroyRenderTask(renderContext, generateListTask);
  generateListTask = nullptr;
 
  assert(!renderList->isOwned());
  renderContext->renderer->getRenderResources().releaseResource(renderList);
  renderContext->renderer->getRenderResources().destroyResource(renderList);
  renderList = nullptr;
 
  for (auto& pipeline : pipelineInstances) {
    releasePipelineInstance(renderContext, pipeline.second.get());
  }
}
 
Cogs::Core::RenderPipelineDefinition&
Cogs::Core::RenderPipelineManager::definitionByPath(Context* context, const StringView& path)
{
  auto insert = [&](size_t hash, StringView myPath) -> RenderPipelineDefinition&
  {
    auto p1 = definitions.emplace(hash, std::make_unique<RenderPipelineDefinition>(parsePipeline(context, myPath)));
    assert(p1.first->second.get());
    auto& definition = *(p1.first->second.get());
    if (!definition.name.empty()) {
      /*auto p2 = */nameMap.insert({ definition.name, hash });
      if (!p1.second) LOG_WARNING(logger, "Collision in nameMap when inserting %s, hash=%zd.", definition.name.c_str(), hash);
    }
 
    for (auto& generator : definition.generators) {
      if (!definition.name.empty()) {
        size_t genHash = StringView(generator.name).hash();
 
        auto pp1 = definitions.emplace(genHash, std::make_unique<RenderPipelineDefinition>(generator));
        assert(pp1.first->second.get());
        if (!pp1.second) LOG_WARNING(logger, "Collision in hashes when inserting %s, hash=%zd.", generator.name.c_str(), genHash);
 
        auto pp2 = nameMap.emplace(generator.name, genHash);
        if (!pp2.second) LOG_WARNING(logger, "Collision in nameMap when inserting %s, hash=%zd.", generator.name.c_str(), genHash);
      }
    }
 
    return definition;
  };
 
  auto queryLoc = path.find("?");
  const auto trimmedPath = queryLoc == StringView::NoPosition ? path : path.substr(0, queryLoc);
 
  size_t hash1 = trimmedPath.hash();
  if (auto it = definitions.find(hash1); it != definitions.end()) {
    return *(it->second.get());
  }
 
  auto& def1 = insert(hash1, trimmedPath);
 
  // Import dependencies. Start with copy of import.
  // Particular processing order doesn't matter here, so we don't care to reverse stack fill.
  std::vector<StringParameter> importStack = def1.imports;
 
  while (!importStack.empty())
  {
    const StringParameter item = importStack.back();
    importStack.pop_back();
 
    size_t hash2 = StringView(item.value).hash();
    if (!definitions.contains(hash2)) {
      const auto& def2 = insert(hash2, item.value);
      for (auto& importValue : def2.imports) {
        importStack.push_back(importValue);
      }
    }
 
    nameMap.insert({ item.key, hash2 });
  }
 
  for (const auto& it : definitions) {
    assert(it.second.get());
  }
 
  return def1;
}
 
std::pair< Cogs::Core::PipelineInstance*, bool> Cogs::Core::RenderPipelineManager::instanceByKey(Context* context, size_t key)
{
  auto it = pipelineInstances.find(key);
  if (it == pipelineInstances.end()) {
    auto instance = pipelineInstances.emplace(key, std::make_unique<PipelineInstance>()).first->second.get();
    instance->touched = context->time->getFrame();
    return std::make_pair(instance, true);
  }
  auto* instance = it->second.get();
  instance->touched = context->time->getFrame();
  return std::make_pair(instance, false);
}
 
void Cogs::Core::RenderPipelineManager::setupPipeline(RenderTaskContext * renderContext)
{
  Context* context = renderContext->context;
  uint32_t frame = context->time->getFrame();
 
  renderList->viewportData = renderContext->cameraData;
 
  expressionContextRoot.add("Cogs.Frame", frame);
  expressionContextRoot.add("Cogs.Time", renderContext->context->time->getAnimationTime());
  expressionContextRoot.add("Cogs.TimeDelta", renderContext->context->time->getAnimationTimeDelta());
  expressionContextRoot.add("Cogs.BackBuffer.width", renderContext->renderer->getSize().x);
  expressionContextRoot.add("Cogs.BackBuffer.height", renderContext->renderer->getSize().y);
  expressionContextRoot.add("Cogs.Mouse.x", (float)context->getDefaultView()->refMouse().getState().position.x);
  expressionContextRoot.add("Cogs.Mouse.y", (float)context->getDefaultView()->refMouse().getState().position.y);
 
  renderContext->expressionContext = &expressionContextRoot;
 
  setupAuxPipelines(renderContext, this, renderList);
  setupExtraPipelineRuns(renderContext, this, renderList);
  setupLightPipelines(renderContext, this, renderList);
  setupCameraArrayPipelines(renderContext, this, renderList);
  setupCameraPipelines(renderContext, this, renderList);
}
 
void Cogs::Core::RenderPipelineManager::initializeFrame(RenderTaskContext * renderContext)
{
  Context* context = renderContext->context;
  const uint32_t frame = context->time->getFrame();
 
  // Remove unused instances.
  // Note that pipelines doesn't necessarily own the resources it is updating,
  // so we don't want to update stale resources. Live pipelines get their
  // 'touched' property set each frame, so if a pipeline is not touched, it is
  // assumed to be dead.
  SmallVector<size_t,50> killList;
  for (const auto& it : pipelineInstances) {
    if (it.second->touched != frame) {
      releasePipelineInstance(renderContext, it.second.get());
      LOG_DEBUG(logger, "Killing pipeline %s.", it.second->name.c_str());
      killList.push_back(it.first);
    }
  }
  for (const auto& it : killList) {
    pipelineInstances.erase(it);
  }
 
  assert(currentPipeline.empty());
 
  currentPipeline.push_back(generateListTask);
 
  // Generate sorted list of pipeline instances to generate global draw list.
  static std::vector<PipelineInstance*> instances;
  instances.reserve(pipelineInstances.size());
  for (auto& it : pipelineInstances) {
    instances.push_back(it.second.get());
  }
  std::sort(instances.begin(), instances.end(), [](const PipelineInstance* a, const PipelineInstance* b) { return a->priority < b->priority; });
 
  for (PipelineInstance* instance : instances) {
    for (auto & sc : instance->pipeline.subContexts) {
      sc->pullVariables(context);
    }
    for (RenderTask* task : instance->pipeline.tasks) {
      currentPipeline.push_back(task);
    }
  }
 
  // Update resources of mainCamera first.
  for (PipelineInstance* instance : instances) {
    if (instance->renderTarget == nullptr) {
      for (RenderTaskResource& r : instance->pipeline.resources.resources) {
        renderContext->resources->updateResource(r.resource);
      }
    }
  }
  for (PipelineInstance* instance : instances) {
    for (RenderTaskResource& r : instance->pipeline.updateResources.resources) {
      renderContext->resources->updateResource(r.resource);
    }
    if (instance->renderTarget != nullptr) {
      for (RenderTaskResource& r : instance->pipeline.resources.resources) {
        renderContext->resources->updateResource(r.resource);
      }
    }
  }
  instances.clear();
 
}
 
void Cogs::Core::RenderPipelineManager::applyPipeline(RenderTaskContext * renderContext)
{
  auto frame = renderContext->context->time->getFrame();
 
  for (auto & task : currentPipeline) {
    if (task->frameMod != 0) {
      if ((frame % task->frameMod) != task->frameOffset) {
        continue;
      }
    }
    task->apply(renderContext);
  }
}
 
void Cogs::Core::RenderPipelineManager::cleanupFrame(RenderTaskContext * /*renderContext*/)
{
  currentPipeline.clear();
}