RenderTask.h

#pragma once
 
#include "Renderer/RenderResource.h"
 
#include "Rendering/Common.h"
 
#include "Foundation/StringView.h"
#include "Foundation/Reflection/Type.h"
 
#include <string>
#include <vector>
#include <functional>
 
namespace Cogs
{
  class IGraphicsDevice;
 
  namespace Core
  {
    struct COGSCORE_DLL_API RenderTaskResource
    {
      std::string key;
      std::string name;
 
      RenderResourceType type;
 
      union
      {
        RenderResource * resource;
        struct RenderTarget * renderTarget;
        struct RenderBuffer * renderBuffer;
        struct RenderList * renderList;
        struct RenderTexture * renderTexure;
      };
    };
 
    struct COGSCORE_DLL_API RenderTaskResources
    {
      void add(RenderResource * resource, const StringView & key = "");
      void add(RenderTaskResource * resource, const StringView & key = "");
      void addResource(RenderResource * resource, const StringView & name);
 
      RenderTaskResource * get(RenderResourceType type);
      RenderTaskResource * get(RenderResourceType type, const StringView & key);
      RenderTaskResource * get(const StringView & name);
 
      const RenderTaskResource * get(const StringView & name) const;
 
      std::vector<RenderTaskResource> resources;
    };
 
    struct RenderTaskContext
    {
      class Context* context = nullptr;
      class Renderer* renderer = nullptr;
      IGraphicsDevice* device = nullptr;
      class RenderResources* resources = nullptr;
      struct RenderStates* states = nullptr;
      const struct CameraData* cameraData = nullptr;
      struct EngineBuffers* engineBuffers = nullptr;
      struct RenderTarget* defaultRenderTarget = nullptr;
      struct ExpressionContext* expressionContext = nullptr;
    };
 
    typedef std::vector<std::pair<std::string, std::string>> PipelineOptions;
 
    struct RenderTaskFlags
    {
      enum ERenderTaskFlags
      {
        None = 0,
        Persistent = 1,
        Static = 2,
      };
    };
 
    struct COGSCORE_DLL_API RenderTask
    {
      virtual ~RenderTask() {}
      virtual void initialize(RenderTaskContext *) {};
      virtual void cleanup(RenderTaskContext *) {};
 
      virtual void apply(RenderTaskContext *) = 0;
 
      bool isStatic() const { return (flags & RenderTaskFlags::Static) != 0; }
 
      RenderTaskResources input;
      RenderTaskResources output;
 
      std::string name;
      std::vector<std::string> dependencies;
 
      PipelineOptions options;
      RenderTaskFlags::ERenderTaskFlags flags = RenderTaskFlags::None;
      bool allowSelfDependency = false;
 
      size_t frameMod = 0;
      size_t frameOffset = 0;
 
      std::function<void(void)> deleter;
    };
 
    typedef std::vector<RenderTask *> RenderTaskList;
  }
}
 
template<> inline Cogs::StringView getName<Cogs::Core::RenderTaskFlags::ERenderTaskFlags>() { return "RenderTaskFlags"; }