RenderPipelineManager.h

#pragma once
 
#include "Tasks/RenderTask.h"
 
#include "RenderSettings.h"
#include "SubContext.h"
#include "Resources/ResourceHandle.h"
#include "Serialization/RenderPipelineReader.h"
 
#include "Utilities/Expressions.h"
 
#include "Foundation/ComponentModel/Component.h"
 
#include <list>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
    class Renderer;
 
    struct RenderPipeline
    {
      RenderPipeline() {}
      RenderPipeline(const RenderPipeline&) = delete;
      RenderPipeline& operator=(const RenderPipeline&) = delete;
 
      RenderTaskList tasks;
 
      RenderTaskResources resources;
      std::vector<ResourceHandleBase> resourceHandles;
 
      RenderTaskResources updateResources;
 
      ExpressionContext expressionContext;
 
      std::list<std::unique_ptr<SubContext>> subContexts;
      std::list<std::string> dependsVariables;
      size_t hash = 0;
    };
 
    struct PipelineInstance
    {
      std::string name;                 
      RenderPipeline pipeline;
      PipelineOptions options;
 
      int priority = 0;
      uint32_t touched = 0;             
      size_t definitionKey = 0;
      size_t dataHash = 0;
      const void* sanityCheck = nullptr;
      RenderTexture* renderTarget = nullptr;  
    };
 
    class COGSCORE_DLL_API RenderPipelineManager
    {
    public:
      RenderPipelineManager() = default;
      RenderPipelineManager(const RenderPipelineManager&) = delete;
      RenderPipelineManager& operator=(const RenderPipelineManager&) = delete;
 
      void initialize(RenderTaskContext* renderContext);
      void cleanup(RenderTaskContext * renderContext);
 
      void setupPipeline(RenderTaskContext * renderContext);
 
      void initializeFrame(RenderTaskContext * renderContext);
      void applyPipeline(RenderTaskContext * renderContext);
      void cleanupFrame(RenderTaskContext * renderContext);
 
      std::pair<PipelineInstance*, bool> instanceByKey(Context* context, size_t key);
 
      ExpressionContext* getExpressionContextRoot() { return &expressionContextRoot; }
 
      struct RenderList * getRenderList() { return renderList; }
 
      RenderPipelineDefinition& definitionByKey(Context * /*context*/, size_t key) { return *(definitions[key].get()); }
 
      const std::unordered_map<size_t, std::unique_ptr<PipelineInstance>> & getPipelineInstances() const { return pipelineInstances; }
      const struct RenderList * getMainRenderList() const { return renderList; }
      const RenderTask * getGenerateListTask() const { return generateListTask; }
 
      RenderPipelineDefinition& definitionByPath(Context * context, const StringView & path);
 
    public:
      std::unordered_map<std::string, size_t> nameMap;
 
      // Hook to insert globally visible resources, will be added to all renderlists.
      RenderTaskResources globalResources;
      bool dirty = true;
 
    private:
      struct RenderList * renderList = nullptr;
      RenderTask * generateListTask = nullptr;
 
      std::unordered_map<size_t, std::unique_ptr<RenderPipelineDefinition>> definitions;
 
      std::unordered_map<size_t, std::unique_ptr<PipelineInstance>> pipelineInstances;
 
      ExpressionContext expressionContextRoot;
 
      RenderTaskList currentPipeline;
    };
  }
}