ShaderBuilder.cpp

#include "ShaderBuilder.h"
#include "Context.h"
#include "ResourceStore.h"
#include "Renderer/EnginePermutations.h"
 
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/StringUtilities.h"
#include "Foundation/StringView.h"
 
namespace
{
  using namespace Cogs::Core;
 
  constexpr size_t InitialBufferCapasity = 4096u;
 
  Cogs::StringView getType(MaterialDataType type)
  {
    return DataTypeNames[static_cast<size_t>(type)];
  }
 
  const char* semanticSlots[] = {
    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
    "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"
  };
 
  struct {
    const char* name;
    bool indexable;
  } semanticInfo[]
  {
    { "", false },
    { "POSITION", true },
    { "NORMAL", true },
    { "COLOR", true },
    { "TEXCOORD", true },
    { "TANGENT", true },
    { "INSTANCEVECTOR", true },
    { "INSTANCEMATRIX", true },
    { "SV_Position", false },
    { "SV_VertexID", false },
    { "SV_InstanceID", false },
    { "SV_ClipDistance", true },
    { "VFACE", false },
    { "SV_ISFrontFace", false }
  };
  static_assert(sizeof(semanticInfo) == sizeof(semanticInfo[0]) * size_t(ShaderInterfaceMemberDefinition::SemanticName::Count));
 
 
  void addVariable(std::string& content,
                   const Cogs::StringView& type,
                   const Cogs::StringView& name,
                   ShaderInterfaceMemberDefinition::SemanticName semantic,
                   uint8_t semanticIndex,
                   ShaderInterfaceMemberDefinition::InterpolationModifiers modifiers = ShaderInterfaceMemberDefinition::NoModifier,
                   bool isArray = false,
                   uint32_t arraySize = 0)
  {
    if ((modifiers & ShaderInterfaceMemberDefinition::LinearModifier) != ShaderInterfaceMemberDefinition::NoModifier) {
      content.append("linear ");
    }
    if ((modifiers & ShaderInterfaceMemberDefinition::CentroidModifier) != ShaderInterfaceMemberDefinition::NoModifier) {
      content.append("centroid ");
    }
    if ((modifiers & ShaderInterfaceMemberDefinition::NointerpolationModifier) != ShaderInterfaceMemberDefinition::NoModifier) {
      content.append("nointerpolation ");
    }
    if ((modifiers & ShaderInterfaceMemberDefinition::NoperspectiveModifier) != ShaderInterfaceMemberDefinition::NoModifier) {
      content.append("noperspective ");
    }
    if ((modifiers & ShaderInterfaceMemberDefinition::SampleModifier) != ShaderInterfaceMemberDefinition::NoModifier) {
      content.append("sample ");
    }
 
    content.append(type.to_string_view());
    content.append(" ");
    content.append(name.to_string_view());
    if (isArray) {
      content.append("[");
      content.append(std::to_string(arraySize));
      content.append("]");
    }
    if (semantic != ShaderInterfaceMemberDefinition::SemanticName::None) {
      content.append(" : ");
      const auto& info = semanticInfo[size_t(semantic)];
      content.append(info.name);
      if (info.indexable) {
        assert(semanticIndex < (sizeof(semanticSlots) / sizeof(size_t)) && "Semantic index out of bounds.");
        content.append(semanticSlots[semanticIndex]);
      }
      else {
        assert(semanticIndex == 0);
      }
    }
    content.append(";\n");
  }
 
  void addVariable(std::string& content,
                   const Cogs::StringView& type,
                   const Cogs::StringView& name,
                   bool isArray = false,
                   uint32_t arraySize = 0)
  {
    addVariable(content, type, name,
                ShaderInterfaceMemberDefinition::SemanticName::None,
                0,
                ShaderInterfaceMemberDefinition::NoModifier,
                isArray, arraySize);
  }
 
  void buildVertexInterface(ResourceStore* resourceStore, const ShaderDefinition& shaderDefinition, const std::string_view& prefix)
  {
    std::string vertexIn;
    vertexIn.reserve(::InitialBufferCapasity);
    vertexIn.append("struct VertexIn {\n");
 
    uint8_t index = 0;
    for (auto& member : shaderDefinition.shaderInterface.members) {
      if (member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID) {
        addVariable(vertexIn, "uint", member.name, member.semantic.name, 0);
      }
      else if (member.semantic.name != ShaderInterfaceMemberDefinition::SemanticName::None) {
        addVariable(vertexIn, getType(member.type), member.name, member.semantic.name, member.semantic.slot);
      }
      else {
        addVariable(vertexIn, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::Texcoord, index);
        index++;
      }
    }
 
    vertexIn.append("};\n");
 
    resourceStore->addResource(Cogs::stringConcatenate({ prefix, "VertexInterface.hlsl" }), vertexIn);
  }
 
  void buildInterface(ResourceStore* resourceStore, const ShaderDefinition& shaderDefinition, const std::string_view& prefix, const std::string_view& stageOut, const std::string_view& stageIn)
  {
    std::string vertexOut;
    vertexOut.reserve(::InitialBufferCapasity);
    vertexOut.append("struct VertexOut {\n");
    std::string vertexIn;
    vertexIn.reserve(::InitialBufferCapasity);
    vertexIn.append("struct VertexIn {\n");
 
    uint8_t index = 0;
    for (const ShaderInterfaceMemberDefinition& member : shaderDefinition.shaderInterface.members) {
      if (member.semantic.name != ShaderInterfaceMemberDefinition::SemanticName::Position) continue;
 
      addVariable(vertexIn, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_Position, 0);
      addVariable(vertexOut, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_Position, 0);
    }
 
    for (const ShaderInterfaceMemberDefinition& member : shaderDefinition.shaderInterface.members) {
      if ((member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID)) {
        addVariable(vertexIn, "uint", member.name, member.semantic.name, 0);
      }
      else if (member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::Position) {
      }
      else if (member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance && (stageOut == "VS" || stageOut == "GS")) {
      }
      else if (member.type == MaterialDataType::Position && stageIn == "PS") {
        addVariable(vertexIn, "float4", member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_Position, 0);
      }
      else if (member.type == MaterialDataType::VFACE && stageIn == "PS") {
        addVariable(vertexIn, "float", member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_VFace, 0);
      }
      else if (member.type == MaterialDataType::SV_IsFrontFace && stageIn == "PS") {
        addVariable(vertexIn, "bool", member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_IsFrontFace, 0);
      }
      else if (member.type == MaterialDataType::SV_InstanceID && (stageIn == "PS" || stageIn == "VS")) {
        addVariable(vertexIn, "uint", member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_InstanceID, 0);
      }
      else if (member.type == MaterialDataType::ClipDistance && (stageOut == "VS" || stageOut == "GS")) {
      }
      else if (member.type == MaterialDataType::Float4Array) {
        // Handle array members.
        std::string pFix = "[" + (member.dimensionString.size() ? member.dimensionString : std::to_string(member.dimension == static_cast<size_t>(-1) ? 1 : member.dimension)) + "]";
 
        addVariable(vertexOut, getType(member.type), member.name + pFix, ShaderInterfaceMemberDefinition::SemanticName::Texcoord, index, member.modifiers);
        addVariable(vertexIn, getType(member.type), member.name + pFix, ShaderInterfaceMemberDefinition::SemanticName::Texcoord, index, member.modifiers);
 
        //TODO: Determine a way to reserve a sane amount of semantic slots here.
        index += member.dimension != static_cast<size_t>(-1) ? uint8_t(member.dimension) : 4;
      }
      else {
        addVariable(vertexOut, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::Color, index, member.modifiers);
        addVariable(vertexIn, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::Color, index, member.modifiers);
        ++index;
      }
    }
 
    if (stageOut == "VS") {
      vertexOut += "uint instanceId : TEXCOORD";
      vertexOut += std::to_string(index);
      vertexOut += ";\n";
    }
 
    // Put these last as these will allocate output registers but won't be part of next stage input, and hlsl requires matching register ordering.
    for (const ShaderInterfaceMemberDefinition& member : shaderDefinition.shaderInterface.members) {
      if (member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance && (stageOut == "VS" || stageOut == "GS")) {
        addVariable(vertexOut, getType(member.type), member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance, member.semantic.slot);
      }
      else if (member.type == MaterialDataType::ClipDistance && (stageOut == "VS" || stageOut == "GS")) {
        addVariable(vertexOut, "float", member.name, ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance, 0);
      }
    }
 
 
    vertexOut += "};\n";
    vertexIn += "};\n";
 
    resourceStore->addResource(Cogs::stringConcatenate({ prefix, "Interface", stageOut, stageIn, ".hlsl" }), vertexOut);
    resourceStore->addResource(Cogs::stringConcatenate({ prefix, "Interface", stageIn, ".hlsl" }), vertexIn);
  }
 
  void buildTransfer(ResourceStore* resourceStore, const ShaderDefinition& sourceDefinition, const ShaderDefinition& destinationDefinition, const std::string_view& prefix, const std::string_view& stage)
  {
    std::string vertexOut;
    vertexOut.reserve(::InitialBufferCapasity);
    vertexOut.append("void transferAttributes(in VertexIn In, inout VertexOut Out) {\n");
 
    for (const ShaderInterfaceMemberDefinition& member : sourceDefinition.shaderInterface.members) {
 
      if (member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID) continue;
 
      for (const ShaderInterfaceMemberDefinition& dMember : destinationDefinition.shaderInterface.members) {
 
        if (dMember.name == member.name) {
 
          vertexOut += "  Out.";
          vertexOut += member.name;
          vertexOut += " = ";
 
          if (dMember.type == MaterialDataType::Float3 && member.type == MaterialDataType::Float2 && member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::Normal) {
            vertexOut += "octDecode(In.";
            vertexOut += member.name;
            vertexOut += ");\n";
            break;
          }
 
          if (dMember.type == MaterialDataType::Float4 && member.type == MaterialDataType::Float3) {
            vertexOut += "float4(In.";
            vertexOut += member.name;
            vertexOut += ", 1.0);\n";
            break;
          }
          if (dMember.type == MaterialDataType::Float4 && member.type == MaterialDataType::Float2) {
            vertexOut += "float4(In.";
            vertexOut += member.name;
            vertexOut += ", 0.0, 1.0);\n";
            break;
          }
          if (dMember.type != member.type) {
 
            switch (dMember.type) {
            case MaterialDataType::Float: vertexOut += "(float)"; break;
            case MaterialDataType::Float2: vertexOut += "(float2)"; break;
            case MaterialDataType::Float3: vertexOut += "(float3)"; break;
            case MaterialDataType::Float4: vertexOut += "(float4)"; break;
            case MaterialDataType::Float4x4: vertexOut += "(Float4x4)"; break;
            case MaterialDataType::Int: vertexOut += "(int)"; break;
            case MaterialDataType::Int2: vertexOut += "(int2)"; break;
            case MaterialDataType::Int3: vertexOut += "(int3)"; break;
            case MaterialDataType::Int4: vertexOut += "(int4)"; break;
            case MaterialDataType::UInt: vertexOut += "(uint)"; break;
            case MaterialDataType::UInt2: vertexOut += "(uint2)"; break;
            case MaterialDataType::UInt3: vertexOut += "(uint3)"; break;
            case MaterialDataType::UInt4: vertexOut += "(uint4)"; break;
            default:
              break;
            }
          }
 
          vertexOut += "In.";
          vertexOut += member.name;
          vertexOut += ";\n";
 
          break;
        }
      }
    }
 
    vertexOut += "};\n";
 
    resourceStore->addResource(Cogs::stringConcatenate({ prefix, "Transfer", stage, ".hlsl" }), vertexOut);
  }
 
  void buildConstantBuffer(std::string& out, const ResourceStore* /*resourceStore*/, const ConstantBufferDefinition& definition)
  {
    out.append("cbuffer ");
    out.append(definition.name);
    out.append(" {\n");
    for (const ConstantBufferVariableDefinition& member : definition.values) {
      out.append(2, ' ');
      out.append(DataTypeNames[static_cast<size_t>(member.type)]);
      out.append(1, ' ');
      out.append(member.name);
      if (member.type == MaterialDataType::Float4Array || member.type == MaterialDataType::Float4x4Array) {
        assert(member.dimension != static_cast<size_t>(-1));
        out.append("[");
        out.append(std::to_string(member.dimension));
        out.append("]");
      }
      out.append(";\n");
    }
    out.append("};\n");
  }
 
  void buildMaterialInterface(ResourceStore* resourceStore, const MaterialDefinition& definition, const EnginePermutation& permutation, const std::string_view& prefix)
  {
    std::string out;
    out.reserve(::InitialBufferCapasity);
 
    for (auto& buffer : permutation.getDefinition()->properties.buffers) {
      buildConstantBuffer(out, resourceStore, buffer);
    }
 
    for (auto& buffer : definition.properties.buffers) {
      buildConstantBuffer(out, resourceStore, buffer);
    }
 
    std::string tmp;
    for (auto& texture : definition.properties.textures) {
 
      // Basic texture type
      std::string_view type;
      switch (texture.dimensions)
      {
      case TextureDimensions::TexureCube:     type = "TextureCube";     break;
      case TextureDimensions::Texture3D:      type = "Texture3D";       break;
      case TextureDimensions::Texture2DArray: type = "Texture2DArray";  break;
      default:                                type = "Texture2D";       break;
      }
 
      // Optionally specify templated parameter for type
      if (texture.format != MaterialDataType::Unknown) {
        tmp = type; // Populate tmp string with basic type, then append to this string
        switch (texture.format) {
        case MaterialDataType::Float:   tmp.append("<float>");  break;
        case MaterialDataType::Float2:  tmp.append("<float2>"); break;
        case MaterialDataType::Float3:  tmp.append("<float3>"); break;
        case MaterialDataType::Float4:  tmp.append("<float4>"); break;
        case MaterialDataType::Int:     tmp.append("<int>");    break;
        case MaterialDataType::Int2:    tmp.append("<int2>");   break;
        case MaterialDataType::Int3:    tmp.append("<int3>");   break;
        case MaterialDataType::Int4:    tmp.append("<int4>");   break;
        case MaterialDataType::UInt:    tmp.append("<uint>");   break;
        case MaterialDataType::UInt2:   tmp.append("<uint2>");  break;
        case MaterialDataType::UInt3:   tmp.append("<uint3>");  break;
        case MaterialDataType::UInt4:   tmp.append("<uint4>");  break;
        default:
          break;
        }
        type = tmp; // let type stringview point to tmp string
      }
 
      addVariable(out, type, texture.name, texture.isArray, texture.arraySize);
 
      addVariable(out, "SamplerState ", texture.name + "Sampler");
    }
 
    resourceStore->addResource(Cogs::stringConcatenate({ prefix, "MaterialInterface.hlsl" }), out);
  }
 
#if 1
  void addDefine(std::string& content, const Cogs::StringView& name, const Cogs::StringView& definition)
  {
    content.append("#define ");
    content.append(name.to_string_view());
    content.append(" ");
    content.append(definition.to_string_view());
    content.append("\n");
  }
#endif
 
  void addInclude(std::string& content, const Cogs::StringView& prefix, const Cogs::StringView& path)
  {
    content.append("#include \"");
    if (prefix.size()) content.append(prefix.to_string_view());
    content.append(path.to_string_view());
    content.append("\"\n");
  }
 
  void addInclude(std::string& content, const Cogs::StringView& path)
  {
    addInclude(content, nullptr, path);
  }
 
  [[nodiscard]] std::string getAttribute(const ShaderDefinition& definition, const Cogs::StringView& key, const Cogs::StringView& defaultValue = Cogs::StringView())
  {
    for (auto& attribute : definition.attributes) {
      if (attribute.key == key) return attribute.value;
    }
 
    return std::string(defaultValue);
  }
 
  [[nodiscard]] bool buildEffectPermutation(ResourceStore* resourceStore,
                                            std::vector<std::pair<std::string, std::string>>& definitions,
                                            const MaterialDefinition& definition, const EnginePermutation& permutation)
  {
    std::string prefix = "" + definition.name;
    std::string includePrefix = definition.name;
 
    buildVertexInterface(resourceStore, definition.effect.vertexShader, prefix);
 
    if (definition.effect.hullShader.entryPoint.size()) {
      buildInterface(resourceStore, definition.effect.hullShader, prefix, "VS", "HS");
      buildTransfer(resourceStore, definition.effect.vertexShader, definition.effect.hullShader, prefix, "VS");
 
      buildInterface(resourceStore, definition.effect.domainShader, prefix, "HS", "DS");
      buildTransfer(resourceStore, definition.effect.hullShader, definition.effect.domainShader, prefix, "HS");
 
      if (definition.effect.geometryShader.entryPoint.size()) {
        buildInterface(resourceStore, definition.effect.geometryShader, prefix, "DS", "GS");
        buildTransfer(resourceStore, definition.effect.domainShader, definition.effect.geometryShader, prefix, "DS");
 
        buildInterface(resourceStore, definition.effect.pixelShader, prefix, "GS", "PS");
        buildTransfer(resourceStore, definition.effect.geometryShader, definition.effect.pixelShader, prefix, "GS");
      }
      else {
        buildInterface(resourceStore, definition.effect.pixelShader, prefix, "DS", "PS");
        buildTransfer(resourceStore, definition.effect.domainShader, definition.effect.pixelShader, prefix, "DS");
      }
    }
    else {
      if (definition.effect.geometryShader.entryPoint.size()) {
        buildInterface(resourceStore, definition.effect.geometryShader, prefix, "VS", "GS");
        buildTransfer(resourceStore, definition.effect.vertexShader, definition.effect.geometryShader, prefix, "VS");
 
        buildInterface(resourceStore, definition.effect.pixelShader, prefix, "GS", "PS");
        buildTransfer(resourceStore, definition.effect.geometryShader, definition.effect.pixelShader, prefix, "GS");
      }
      else {
        buildInterface(resourceStore, definition.effect.pixelShader, prefix, "VS", "PS");
        buildTransfer(resourceStore, definition.effect.vertexShader, definition.effect.pixelShader, prefix, "VS");
      }
    }
 
    buildMaterialInterface(resourceStore, definition, permutation, prefix);
 
    std::string vsContent;
    vsContent.reserve(::InitialBufferCapasity);
    addInclude(vsContent, definition.effect.vertexShader.customSourcePath);
 
    resourceStore->addResource(prefix + "VertexFunction.hlsl", vsContent);
 
    std::string psContent;
    psContent.reserve(::InitialBufferCapasity);
    addInclude(psContent, definition.effect.pixelShader.customSourcePath);
 
    resourceStore->addResource(prefix + "SurfaceFunction.hlsl", psContent);
 
    {
      std::string metaContentVS;
      metaContentVS.reserve(::InitialBufferCapasity);
      addInclude(metaContentVS, "Engine/Common.hlsl");
      addInclude(metaContentVS, includePrefix, "VertexInterface.hlsl");
 
      if (definition.effect.hullShader.entryPoint.size()) {
        addInclude(metaContentVS, includePrefix, "InterfaceVSHS.hlsl");
      }
      else {
        if (definition.effect.geometryShader.entryPoint.size()) {
          addInclude(metaContentVS, includePrefix, "InterfaceVSGS.hlsl");
        }
        else {
          addInclude(metaContentVS, includePrefix, "InterfaceVSPS.hlsl");
        }
      }
 
      addInclude(metaContentVS, includePrefix, "TransferVS.hlsl");
      addInclude(metaContentVS, includePrefix, "MaterialInterface.hlsl");
      addInclude(metaContentVS, includePrefix, "VertexFunction.hlsl");
 
      definitions.emplace_back("VERTEX_FUNCTION", "invokeMaterial");
      addInclude(metaContentVS, "Engine/EngineVS.hlsl");
 
      if (definition.effect.vertexShader.entryPoint != "main") {
        definitions.emplace_back("MATERIAL_VERTEX_FUNCTION", definition.effect.vertexShader.entryPoint.empty() ? "vertexFunction" : definition.effect.vertexShader.entryPoint);
        addInclude(metaContentVS, permutation.getDefinition()->vertexShader);
      }
 
      resourceStore->addResource(Cogs::stringConcatenate({ prefix, "VertexShader", permutation.getDefinition()->name, ".hlsl" }), metaContentVS);
    }
 
    if (definition.effect.hullShader.customSourcePath.size()) {
      std::string hsContent;
      hsContent.reserve(::InitialBufferCapasity);
      addInclude(hsContent, definition.effect.hullShader.customSourcePath);
 
      resourceStore->addResource(prefix + "HullFunction.hlsl", hsContent);
 
      std::string metaContentHS;
      metaContentHS.reserve(::InitialBufferCapasity);
      addInclude(metaContentHS, "Engine/Common.hlsl");
      addInclude(metaContentHS, includePrefix, "InterfaceHS.hlsl");
      addInclude(metaContentHS, includePrefix, "InterfaceHSDS.hlsl");
      addInclude(metaContentHS, includePrefix, "TransferHS.hlsl");
      addInclude(metaContentHS, includePrefix, "MaterialInterface.hlsl");
      addInclude(metaContentHS, includePrefix, "HullFunction.hlsl");
 
      resourceStore->addResource(Cogs::stringConcatenate({ prefix, "HullShader", permutation.getDefinition()->name, ".hlsl" }), metaContentHS);
    }
 
    if (definition.effect.domainShader.customSourcePath.size()) {
      std::string dsContent;
      dsContent.reserve(::InitialBufferCapasity);
      addInclude(dsContent, definition.effect.domainShader.customSourcePath);
 
      resourceStore->addResource(prefix + "DomainFunction.hlsl", dsContent);
 
      std::string metaContentDS;
      metaContentDS.reserve(::InitialBufferCapasity);
      addInclude(metaContentDS, "Engine/Common.hlsl");
      addInclude(metaContentDS, includePrefix, "InterfaceDS.hlsl");
 
      if (definition.effect.geometryShader.entryPoint.size()) {
        addInclude(metaContentDS, includePrefix, "InterfaceDSGS.hlsl");
      }
      else {
        addInclude(metaContentDS, includePrefix, "InterfaceDSPS.hlsl");
      }
 
      addInclude(metaContentDS, includePrefix, "TransferDS.hlsl");
      addInclude(metaContentDS, includePrefix, "MaterialInterface.hlsl");
      addInclude(metaContentDS, includePrefix, "DomainFunction.hlsl");
 
      resourceStore->addResource(Cogs::stringConcatenate({ prefix, "DomainShader", permutation.getDefinition()->name, ".hlsl" }), metaContentDS);
    }
 
    if (definition.effect.geometryShader.customSourcePath.size()) {
      std::string gsContent;
      gsContent.reserve(::InitialBufferCapasity);
      addInclude(gsContent, definition.effect.geometryShader.customSourcePath);
 
      resourceStore->addResource(prefix + "GeometryFunction.hlsl", gsContent);
 
      std::string metaContentGS;
      metaContentGS.reserve(::InitialBufferCapasity);
      addInclude(metaContentGS, "Engine/Common.hlsl");
      addInclude(metaContentGS, includePrefix, "InterfaceGS.hlsl");
      addInclude(metaContentGS, includePrefix, "InterfaceGSPS.hlsl");
      addInclude(metaContentGS, includePrefix, "TransferGS.hlsl");
      addInclude(metaContentGS, includePrefix, "MaterialInterface.hlsl");
      addInclude(metaContentGS, includePrefix, "GeometryFunction.hlsl");
 
      if (definition.effect.geometryShader.entryPoint != "main") {
        if (definition.effect.geometryShader.entryPoint != "geometryFunction") {
          definitions.emplace_back("GEOMETRY_FUNCTION", definition.effect.geometryShader.entryPoint);
        }
 
        auto gsPrimitiveType = getAttribute(definition.effect.geometryShader, "primitivetype", "point");
 
        definitions.emplace_back("MAX_VERTEX_COUNT", getAttribute(definition.effect.geometryShader, "maxvertexcount", "0"));
        definitions.emplace_back("GS_PRIMITIVE_TYPE", gsPrimitiveType);
 
        int gsElementCount = 1;
        if (gsPrimitiveType == "line") {
          gsElementCount = 2;
        }
        else if (gsPrimitiveType == "lineadj") {
          gsElementCount = 4;
        }
        else if (gsPrimitiveType == "triangle") {
          gsElementCount = 3;
        }
        else if (gsPrimitiveType == "triangleadj") {
          gsElementCount = 6;
        }
 
        definitions.emplace_back("GS_ELEMENT_COUNT", std::to_string(gsElementCount));
 
        addInclude(metaContentGS, permutation.getDefinition()->geometryShader);
      }
 
      resourceStore->addResource(Cogs::stringConcatenate({ prefix, "GeometryShader", permutation.getDefinition()->name, ".hlsl" }), metaContentGS);
    }
 
    {
      std::string metaContentPS;
      metaContentPS.reserve(::InitialBufferCapasity);
 
      for (const std::pair<std::string, std::string>& define : definitions) {
        addDefine(metaContentPS, define.first, define.second);
      }
 
      addInclude(metaContentPS, "Engine/Common.hlsl");
      addInclude(metaContentPS, includePrefix, "InterfacePS.hlsl");
      addInclude(metaContentPS, includePrefix, "MaterialInterface.hlsl");
      addInclude(metaContentPS, includePrefix, "SurfaceFunction.hlsl");
 
      // If entrypoint is main material interfaces render target directly
      if (definition.effect.pixelShader.entryPoint != "main") {
        definitions.emplace_back("SURFACE_FUNCTION", "invokeMaterial");
        addInclude(metaContentPS, "Engine/EnginePS.hlsl");
 
        definitions.emplace_back("MATERIAL_SURFACE_FUNCTION", definition.effect.pixelShader.entryPoint.empty() ? "surfaceFunction" : definition.effect.pixelShader.entryPoint);
        addInclude(metaContentPS, permutation.getDefinition()->pixelShader);
      }
 
      resourceStore->addResource(Cogs::stringConcatenate({ prefix, "PixelShader", permutation.getDefinition()->name, ".hlsl" }), metaContentPS);
    }
    return true;
  }
}
 
bool Cogs::Core::buildEffect(class Context* context,
                             std::vector<std::pair<std::string, std::string>>& definitions,
                             const MaterialDefinition& materialPermutation,
                             const EnginePermutation& permutation)
{
  return buildEffectPermutation(context->resourceStore.get(), definitions, materialPermutation, permutation);
}