RenderPipelineDefinition.h

#pragma once
 
#include "Renderer/RenderResource.h"
#include "Utilities/Parsing.h"
 
#include "Foundation/StringView.h"
 
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    struct StringParameter
    {
      std::string key;
      std::string value;
      std::vector<StringParameter> values;
    };
 
    struct RenderResourceDefinition
    {
      std::string name;
      std::string alias;
 
      RenderResourceType type = RenderResourceType::Unknown;
 
      std::vector<ParsedValue> parameters;
 
      std::vector<std::string> textures;
 
      std::string condition;
 
      const ParsedValue* getParameter(const StringView& key) const
      {
        for (auto& p : parameters) {
          if (key == p.key) {
            return &p;
          }
        }
 
        return nullptr;
      }
 
      const ParsedValue * getParameter(const StringView & key, const StringView & /*fallback*/) const
      {
        return getParameter(key);
      }
 
      const ParsedValue * getParameter(const StringView & key, const char * fallback) const
      {
        return getParameter(key, StringView(fallback));
      }
 
      bool getParameter(const StringView & key, bool fallback) const
      {
        auto p = getParameter(key, "");
 
        return (p && p->type == ParsedDataType::Bool) ? p->boolValue : fallback;
      }
 
      int getParameter(const StringView & key, int fallback) const
      {
        auto p = getParameter(key, "");
 
        return (p && p->type == ParsedDataType::Int) ? p->intValue : fallback;
      }
    };
 
    struct RenderTaskSlot
    {
      RenderTaskSlot(const std::string & key, const std::string & value) : key(key), value(value) {}
      RenderTaskSlot(const std::string & value) : value(value) {}
 
      std::string key;
      std::string value;
    };
 
    struct RenderTaskDefinition
    {
      std::string name;
 
      std::string type;
 
      std::vector<RenderTaskSlot> inputs;
      std::vector<RenderTaskSlot> outputs;
 
      std::vector<std::string> dependencies;
 
      std::vector<ParsedValue> parameters;
      std::vector<StringParameter> options;
 
      std::string condition;
    };
 
    struct ParsedOption
    {
      std::string key;
      std::vector<std::string> values;
 
      std::string setting;
    };
 
    struct RenderPipelineDefinition
    {
      std::string name;
      std::vector<ParsedOption> options;
 
      std::vector<RenderResourceDefinition> resources;
      std::vector<RenderTaskDefinition> tasks;
 
      std::vector<StringParameter> imports;
      std::vector<RenderPipelineDefinition> generators;
 
      std::vector<RenderTaskSlot> inputs;
      std::vector<RenderTaskSlot> outputs;
 
      std::vector<ParsedValue> useVariables;
      std::vector<ParsedValue> setVariables;
      std::vector<ParsedValue> useComponentFields;
    };
  }
}