ShaderBuilderWebGPU.cpp

#include "ShaderBuilder.h"
#include "Context.h"
#include "Utilities/Strings.h"
#include "Utilities/Preprocessor.h"
#include "ResourceStore.h"
#include "Renderer/EnginePermutations.h"
#include "Rendering/IGraphicsDevice.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <array>
#include <sstream>
#include <map>
 
namespace
{
  constexpr size_t InitialBufferCapasity = 4096u;
 
  constexpr std::array semanticNames
  {
    "a_POSITION",
    "a_NORMAL",
    "a_COLOR",
    "a_TEXCOORD",
    "a_TANGENT",
    "a_INSTANCEVECTOR",
    "a_INSTANCEMATRIX",
  };
 
 
  [[nodiscard]]
  std::string_view getSemanticName(size_t semantic_ind) {
    std::string_view name;
    if (semantic_ind < semanticNames.size()) {
      name = semanticNames[semantic_ind];
    }
    return name;
  }
 
  using namespace Cogs::Core;
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ShaderBuilderWebGPU");
 
  enum ShaderInterface { None = 0, VertexIn = 1, VertexOut = 2, FragmentIn = 4, FragmentOut = 8 };
 
  struct BuiltinAttributeDescription {
    std::string builtinName;
    MaterialDataType type = MaterialDataType::Unknown;
    ShaderInterface stage = ShaderInterface::None;
  };
 
  struct BuiltinAttributes {
    ShaderInterfaceMemberDefinition::SemanticName semanticName;
    BuiltinAttributeDescription desc;
  };
 
  const std::array<BuiltinAttributes, 5> builtinAttributes{
      BuiltinAttributes{ShaderInterfaceMemberDefinition::SemanticName::SV_InstanceID, {"instance_index", MaterialDataType::UInt, ShaderInterface::VertexIn}},
      BuiltinAttributes{ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID, {"vertex_index", MaterialDataType::UInt, ShaderInterface::VertexIn}},
      BuiltinAttributes{ShaderInterfaceMemberDefinition::SemanticName::Position, {"position", MaterialDataType::Float4, ShaderInterface(ShaderInterface::VertexOut | ShaderInterface::FragmentIn)}},
      BuiltinAttributes{ShaderInterfaceMemberDefinition::SemanticName::SV_IsFrontFace, {"front_facing", MaterialDataType::Bool, ShaderInterface::FragmentIn}},
      BuiltinAttributes{ShaderInterfaceMemberDefinition::SemanticName::SV_VFace, {"front_facing", MaterialDataType::Bool, ShaderInterface::FragmentIn}},
    };
 
  struct BuiltinDataType {
    Cogs::Core::MaterialDataType type;
    BuiltinAttributeDescription desc;
  };
 
  const std::array builtinDataTypes {
    BuiltinDataType{MaterialDataType::SV_InstanceID, {"instance_index", MaterialDataType::UInt, ShaderInterface::VertexIn} },
    BuiltinDataType{MaterialDataType::Position, {"position", MaterialDataType::Float4, ShaderInterface(ShaderInterface::VertexOut | ShaderInterface::FragmentIn)}},
    BuiltinDataType{MaterialDataType::SV_IsFrontFace, {"front_facing", MaterialDataType::Bool, ShaderInterface::FragmentIn} },
    BuiltinDataType{MaterialDataType::VFACE, {"front_facing", MaterialDataType::Bool, ShaderInterface::FragmentIn}},
  };
 
  const std::array optionalEngineBuffers = {
    "SceneBuffer",
    "ObjectBuffer",
    "AnimationBuffer",
  };
 
  struct EngineTexture {
    std::string name;
    Cogs::Core::TextureDimensions dimensions;
    bool isDepthTexture = false;
  };
 
  const std::array engineTextures = {
   EngineTexture{.name = "environmentSky", .dimensions = TextureDimensions::TexureCube},
   EngineTexture{.name = "environmentRadiance", .dimensions = TextureDimensions::TexureCube},
   EngineTexture{.name = "environmentIrradiance", .dimensions = TextureDimensions::TexureCube},
   EngineTexture{.name = "ambientIrradiance", .dimensions = TextureDimensions::TexureCube},
   EngineTexture{.name = "brdfLUT", .dimensions = TextureDimensions::Texture2D},
   EngineTexture{.name = "cascadedShadowMap", .dimensions = TextureDimensions::Texture2DArray, .isDepthTexture = true},
   EngineTexture{.name = "cubeShadowMap", .dimensions = TextureDimensions::TexureCube, .isDepthTexture = true},
  };
 
  struct WebGPULocation {
    size_t location = 0;
    std::string name;
    Cogs::Core::TextureDimensions dimensions = Cogs::Core::TextureDimensions::Texture2D;
    bool isDepthTexture = false;
    WebGPULocation(size_t location, const std::string &name, Cogs::Core::TextureDimensions dimensions = Cogs::Core::TextureDimensions::Texture2D, bool isDepthTexture = false) :
    location(location), name(name), dimensions(dimensions), isDepthTexture(isDepthTexture) {  }
    WebGPULocation() = default;
 
  };
 
  using WebGPUBindingGroup = std::vector<WebGPULocation>;
  using WebGPUBindingGroupVector = std::vector<WebGPUBindingGroup>;
 
  [[nodiscard]]
  bool hasBinding(const WebGPUBindingGroupVector& bindingGroups, std::string_view name) {
    for (const WebGPUBindingGroup& bindings : bindingGroups) {
      for (const WebGPULocation& location : bindings) {
        if (location.name == name) {
          return true;
        }
      }
    }
    return false;
  }
 
  void createBufferBinding(WebGPUBindingGroupVector& bindingGroups, const MaterialDefinition& materialDefinition) {
    if (bindingGroups.empty()) {
      bindingGroups.emplace_back();
    }
    WebGPUBindingGroup& locations = bindingGroups[0];
    locations.emplace_back(0, "BLOCKED"); // The location will be used as a handle in EffectsWebGPU. We want to avoid 0 as it is considered as HoHandle
 
    for (auto& buffer : optionalEngineBuffers) {
      locations.emplace_back(locations.size(), buffer);
    }
 
    for (auto& buffer : materialDefinition.properties.buffers) {
      if (std::find(std::begin(optionalEngineBuffers), std::end(optionalEngineBuffers), buffer.name) == std::end(optionalEngineBuffers)) {
        if (!hasBinding(bindingGroups, buffer.name)) {
          locations.emplace_back(locations.size(), buffer.name);
        }
      }
    }
  }
 
  [[nodiscard]]
  std::string convertDefinesToConstExpressions(const std::string& s) {
    std::map<std::string, std::string> addedDefines;
    std::string result;
    result.reserve(s.size());
 
    std::istringstream iss(s);
 
    std::string identifier;
    std::string replacement;
    for (std::string line; std::getline(iss, line); )
    {
      identifier.clear();
      replacement.clear();
 
      std::string_view sv(line);
      auto pos = sv.find_first_not_of(" \t");
      if (pos == std::string_view::npos || sv.substr(pos, 7) != "#define") {
        result += line + "\n";
        continue;
      }
      sv = sv.substr(pos + 7);
 
      pos = sv.find_first_not_of(" \t");
      if (pos == std::string_view::npos) {
        result += line + "\n";
        continue;
      }
      sv = sv.substr(pos);
 
      auto end = sv.find_first_of(" \t");
      if (end == std::string_view::npos) {
        identifier = sv;
        replacement = "1";
      } else {
        identifier = sv.substr(0, end);
        sv = sv.substr(end);
        pos = sv.find_first_not_of(" \t");
        if (pos == std::string_view::npos) {
          replacement = "1";
        } else {
          auto last = sv.find_last_not_of(" \t");
          replacement = sv.substr(pos, last - pos + 1);
        }
      }
 
      auto it = addedDefines.find(identifier);
      if (it != addedDefines.end()) {
        if (replacement != (*it).second) {
          LOG_WARNING(logger, "Shader generation with inconsistent preprosessor define %s set to %s conflicts with previous define %s.", identifier.c_str(), replacement.c_str(), (*it).second.c_str());
        }
        continue;
      }
      result += "const " + identifier + " = " + replacement + ";\n";
      addedDefines.try_emplace(identifier, replacement);
    }
    return result;
  }
 
  void addInclude(std::string& content, std::string_view prefix, std::string_view path)
  {
    content.append("#include \"");
    content.append(prefix);
    content.append(path);
    content.append("\"\n");
  }
 
  void changeSuffix(std::string& dst, std::string_view from, std::string_view to)
  {
    if (dst.ends_with(from)) {
      dst.replace(dst.size() - from.length(), from.length(), to);
    }
  }
 
  [[nodiscard]]
  std::string attributeVaryingType(const MaterialDataType type)
  {
    switch (type) {
    case MaterialDataType::Float:           return "f32 "; break;
    case MaterialDataType::Float2:          return "vec2f ";  break;
    case MaterialDataType::Float3:          return "vec3f ";  break;
    case MaterialDataType::Float4:          return "vec4f ";  break;
    case MaterialDataType::Float4x4:        return "mat4x4f ";  break;
    case MaterialDataType::Int:             return "i32 ";   break;
    case MaterialDataType::Int2:            return "vec4i "; break;
    case MaterialDataType::Int3:            return "vec3i "; break;
    case MaterialDataType::Int4:            return "vec4i "; break;
    case MaterialDataType::UInt:            return "u32 ";   break;
    case MaterialDataType::UInt2:           return "vec4u "; break;
    case MaterialDataType::UInt3:           return "vec3u "; break;
    case MaterialDataType::UInt4:           return "vec4u "; break;
    case MaterialDataType::Bool:           return "bool "; break;
    case MaterialDataType::SV_IsFrontFace:  return "bool ";  break;
    case MaterialDataType::VFACE:           return "f32 "; break;
    case MaterialDataType::Position:        return "vec4f ";  break;
    default:
      LOG_ERROR(logger, "Unsupported attribute type %d", int(type));
      return "<illegal>";
      break;
    }
  }
 
  void createTextureBindings(WebGPUBindingGroupVector& bindingGroups, const MaterialDefinition& materialDefinition) {
    if (bindingGroups.empty()) {
      bindingGroups.emplace_back();
    }
    WebGPUBindingGroup& locations = bindingGroups[0];
 
    for (auto& texture : materialDefinition.properties.textures) {
      if (!hasBinding(bindingGroups, texture.name)) {
        std::string name = texture.name;
        locations.emplace_back(locations.size(), name, texture.dimensions);
        locations.emplace_back(locations.size(), name + "Sampler", texture.dimensions, texture.isDepth);
      }
    }
  }
 
  void createEngineTextureBindings(WebGPUBindingGroupVector& bindingGroups) {
    if (bindingGroups.empty()) {
      bindingGroups.emplace_back();
    }
    WebGPUBindingGroup& locations = bindingGroups[0];
 
    for (auto& tex : engineTextures) {
      if (!hasBinding(bindingGroups, tex.name)) {
        std::string name = tex.name;
        locations.emplace_back(locations.size(), name, tex.dimensions, tex.isDepthTexture);
        locations.emplace_back(locations.size(), name + "Sampler", tex.dimensions, tex.isDepthTexture);
      }
    }
  }
 
  void addEffectDefinesAndStuff(std::string& output, const std::vector<std::pair<std::string, std::string>>& definitions, uint32_t multiViewCount) {
    if (multiViewCount) {
      std::string multiViewCountString = std::to_string(multiViewCount);
      output.append("#extension GL_OVR_multiview : require\nlayout(num_views=");
      output.append(multiViewCountString);
      output.append(") in;\n");
      output.append("#define COGS_MULTIVIEW ");
      output.append(multiViewCountString);
      output.append("\n");
    }
 
    std::unordered_set<std::string> addedDefines;
 
    for (const std::pair<std::string, std::string>& define : definitions) {
      if (addedDefines.contains(define.first)) {
        continue;
      }
      output.append("#define ");
      output.append(define.first);
      output.append(" ");
      output.append(define.second);
      output.append("\n");
      addedDefines.insert(define.first);
    }
  }
 
  [[nodiscard]]
  BuiltinAttributeDescription getBuiltinAttributeDescription(const ShaderInterfaceMemberDefinition& attribute) {
    BuiltinAttributeDescription desc;
    desc.stage = ShaderInterface::None;
    for (const auto& builtin : builtinDataTypes)
    {
      if (builtin.type == attribute.type) {
        desc = builtin.desc;
      }
    }
    for (const auto& attr : builtinAttributes) {
      if (attr.semanticName == attribute.semantic.name) {
        desc = attr.desc;
      }
    }
    return desc;
  }
 
  void addInterfaceStruct(std::string& defines, std::string& source, std::string_view name, const ShaderInterfaceDefinition& iface, ShaderInterface shaderInterface)
  {
    size_t next_loc = 0;
    source.append("struct ");
    source.append(name);
    source.append(" {\n");
 
    if (shaderInterface & ShaderInterface::VertexOut) {
      source.append("  @builtin(position) Position: vec4f,\n");
    }
    for (const auto& attribute : iface.members) {
      BuiltinAttributeDescription builtinAttributeDescription = getBuiltinAttributeDescription(attribute);
      if (shaderInterface & ShaderInterface::VertexOut &&
        (builtinAttributeDescription.stage & ShaderInterface::FragmentIn) != 0) {
        continue;
      }
      if (shaderInterface & ShaderInterface::FragmentIn && attribute.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::None && attribute.type == MaterialDataType::Position) {
        continue; // Position is often described both through semantic name and attribute type
      }
 
      if ((builtinAttributeDescription.stage & shaderInterface) != 0) {
        source.append("  @builtin(" + builtinAttributeDescription.builtinName + ") ");
        source.append(attribute.name);
        source.append(" : ");
        source.append(attributeVaryingType(builtinAttributeDescription.type));
        source.append(",\n");
      }
      else {
        if (shaderInterface & ShaderInterface::VertexIn) {
          size_t nameInd = size_t (attribute.semantic.name) - 1;
          std::string_view semanticName = getSemanticName(nameInd);
          if (!semanticName.empty()) {
            if(attribute.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::InstanceMatrix){
              std::string defineName;
              defineName.append(semanticName);
              int loc = attribute.semantic.slot;
              defineName.append(std::to_string(loc) + "_LOC");
              defines.append("#define ");
              defines.append(defineName + " " + std::to_string(next_loc) + "\n");
              next_loc += 4;
              for(int i=0; i<4; i++){
                source.append("  @location(" + defineName + " + " + std::to_string(i) + ") ");
                source.append(attribute.name + "_" + std::to_string(i));
                source.append(" : vec4f,\n");
              }
            }
            else
            {
              std::string defineName;
              defineName.append(semanticName);
              defineName.append(std::to_string(attribute.semantic.slot) + "_LOC");
              defines.append("#define ");
              defines.append(defineName + " " + std::to_string(next_loc++) + "\n");
              source.append("  @location(" + defineName + ") ");
              source.append(attribute.name);
              source.append(" : ");
              source.append(attributeVaryingType(attribute.type));
              source.append(",\n");
            }
          }
        }
        else {
          source.append("  @location(" + std::to_string(next_loc++) + ") ");
          source.append(attribute.name);
          source.append(" : ");
          source.append(attributeVaryingType(attribute.type));
          source.append(",\n");
        }
      }
    }
    source.append("};\n\n");
  }
 
  void addInterfaceConstructor(std::string& shaderSource, std::string_view name, const ShaderInterfaceDefinition& iface)
  {
    shaderSource.append("fn create");
    shaderSource.append(name);
    shaderSource.append("() -> ");
    shaderSource.append(name);
    shaderSource.append(" {\n");
    shaderSource.append("  var t : ");
    shaderSource.append(name);
    shaderSource.append(";\n");
    for (const auto& attribute : iface.members) {
      const char* initializer = nullptr;
      switch (attribute.type) {
      case MaterialDataType::Float:     initializer = "0.0;\n"; break;
      case MaterialDataType::Float2:    initializer = "vec2f(0);\n"; break;
      case MaterialDataType::Float3:    initializer = "vec3f(0);\n"; break;
      case MaterialDataType::Float4:    initializer = "vec4f(0);\n"; break;
      case MaterialDataType::Float4x4:  initializer = "mat4x4f(0);\n"; break;
      default:
        break;
      }
      if (initializer) {
        shaderSource.append("    t.");
        shaderSource.append(attribute.name);
        shaderSource.append(" = ");
        shaderSource.append(initializer);
      }
    }
    shaderSource.append("    return t;\n}\n\n");
  }
 
  void addUniform(std::string& shaderSource, WebGPUBindingGroupVector& bindingGroups, std::string_view name, std::string_view type, bool useTemplate = false) {
    WebGPUBindingGroup& bindings = bindingGroups[0];
    WebGPULocation location;
    for (const WebGPULocation& curr_location : bindings) {
      if (curr_location.name == name) {
        location = curr_location;
        break;
      }
    }
    if (location.name != name) {
      LOG_WARNING(logger, "adding to bindgroup %s", std::string(name).c_str());
      location = WebGPULocation(bindings.size(), std::string(name));
      bindings.push_back(location);
    }
    shaderSource.append("@group(");
    shaderSource.append(std::to_string(0));
    shaderSource.append(") @binding(");
    shaderSource.append(std::to_string(location.location));
    shaderSource.append(") var");
    if (useTemplate) {
      shaderSource.append("<uniform>");
    }
    shaderSource.append(" ");
    shaderSource.append(name);
    shaderSource.append(" : ");
    shaderSource.append(type);
    shaderSource.append(";\n");
  }
 
  void addUniformBuffer(std::string& shaderSource, const std::unordered_set<Cogs::Core::StringRef>& identifiersSeen, const ConstantBufferDefinition& definition, WebGPUBindingGroupVector& bindingGroups)
  {
    if (!identifiersSeen.contains(Strings::add(definition.name))) {
      return;
    }
    if (definition.values.empty()) return;
    shaderSource.append("struct ");
    shaderSource.append(definition.name);
    shaderSource.append("_t {\n");
    for (const ConstantBufferVariableDefinition& member : definition.values) {
      shaderSource.append(member.name);
      shaderSource.append(" : ");
 
      switch (member.type) {
      case MaterialDataType::Float:     shaderSource.append("f32");      break;
      case MaterialDataType::Float2:    shaderSource.append("vec2f");    break;
      case MaterialDataType::Float3:    shaderSource.append("vec3f");    break;
      case MaterialDataType::Float4Array:
      shaderSource.append("array<vec4f, " + std::to_string(member.dimension) + ">");
      assert(member.dimension != static_cast<size_t>(-1));
      break;
      case MaterialDataType::Float4:    shaderSource.append("vec4f");    break;
      case MaterialDataType::Float4x4Array:
      case MaterialDataType::Float4x4:  shaderSource.append("mat4x4f");  break;
      case MaterialDataType::Int:       shaderSource.append("i32");      break;
      case MaterialDataType::Int2:      shaderSource.append("vec2i");    break;
      case MaterialDataType::Int3:      shaderSource.append("vec3i");    break;
      case MaterialDataType::Int4:      shaderSource.append("vec4i");    break;
      case MaterialDataType::UInt:      shaderSource.append("u32");      break;
      case MaterialDataType::UInt2:     shaderSource.append("vec2u");    break;
      case MaterialDataType::UInt3:     shaderSource.append("vec3u");    break;
      case MaterialDataType::UInt4:     shaderSource.append("vec4u");    break;
      case MaterialDataType::Bool:      shaderSource.append("u32");       break;
      default:
        LOG_ERROR(logger, "Invalid type for buffer varable %s in buffer %s.", member.name.c_str(), definition.name.c_str());
        shaderSource.append("<invalid type>");
        break;
      }
      shaderSource.append(",\n");
    }
    shaderSource.append("};\n");
 
    addUniform(shaderSource, bindingGroups, definition.name, definition.name + "_t", true);
  }
 
  void addEngineBuffers(std::string& shaderSource, const std::unordered_set<Cogs::Core::StringRef>& identifiersSeen, WebGPUBindingGroupVector& bindingGroups) {
    for (const std::string& name : optionalEngineBuffers) {
      bool add = false;
      if (identifiersSeen.contains(Strings::add(name))){
        add = true;
      }
      if (name == "SceneBuffer") {
        const char *getters[] = {
          "getClipFromViewMatrix",
          "getClipFromWorldMatrix",
          "getViewFromWorldMatrix",
          "getViewFromClipMatrix",
          "getWorldFromViewMatrix",
          "getViewFromViewportMatrix",
          "getPeriodicWorldPosAndCell",
          "getPeriodicWorldPos"
        };
        for(auto &get : getters){
          if (identifiersSeen.contains(Strings::add(get))){
            add = true;
          }
        }
      }
      if (add) {
        addUniform(shaderSource, bindingGroups, name, name + "_t", true);
        if (name == "SceneBuffer") {
          shaderSource.append("#define COGS_VIEWGETTERS_REFERENCED 1\n");
        }
      }
    }
  }
 
  void addTransferFunc(std::string& shaderSource, const ShaderDefinition& sourceDefinition, const ShaderDefinition& destinationDefinition)
  {
    shaderSource.append("fn transferAttributes(vertexIn : VertexIn, vertexOut : ptr<function, VertexOut>) {\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) {
          shaderSource.append("  (*vertexOut).");
          shaderSource.append(member.name);
          shaderSource.append(" = ");
          if (dMember.type == MaterialDataType::Float3 && member.type == MaterialDataType::Float2 && member.semantic.name == ShaderInterfaceMemberDefinition::SemanticName::Normal) {
            shaderSource.append("octDecode(vertexIn.");
            shaderSource.append(member.name);
            shaderSource.append("); \n");
            break;
          }
          if (dMember.type == MaterialDataType::Float4 && member.type == MaterialDataType::Float3) {
            shaderSource.append("vec4f(vertexIn.");
            shaderSource.append(member.name);
            shaderSource.append(", 1.0);\n");
            break;
          }
          if (dMember.type == MaterialDataType::Float4 && member.type == MaterialDataType::Float2) {
            shaderSource.append("vec4f(vertexIn.");
            shaderSource.append(member.name);
            shaderSource.append(", 0.0, 1.0);\n");
            break;
          }
          bool close = false;
          if (dMember.type != member.type) {
            switch (dMember.type) {
            case MaterialDataType::Float:     shaderSource.append("f32(");  close = true; break;
            case MaterialDataType::Float2:    shaderSource.append("vec2f(");   close = true; break;
            case MaterialDataType::Float3:    shaderSource.append("vec3f(");   close = true; break;
            case MaterialDataType::Float4:    shaderSource.append("vec4f(");   close = true; break;
            case MaterialDataType::Float4x4:  shaderSource.append("mat4x4f(");   close = true; break;
            case MaterialDataType::Int:       shaderSource.append("i32(");    close = true; break;
            case MaterialDataType::Int2:      shaderSource.append("vec2i(");  close = true; break;
            case MaterialDataType::Int3:      shaderSource.append("vec3i(");  close = true; break;
            case MaterialDataType::Int4:      shaderSource.append("vec4i(");  close = true; break;
            case MaterialDataType::UInt:      shaderSource.append("u32(");   close = true; break;
            case MaterialDataType::UInt2:     shaderSource.append("vec2u(");  close = true; break;
            case MaterialDataType::UInt3:     shaderSource.append("vec3u(");  close = true; break;
            case MaterialDataType::UInt4:     shaderSource.append("vec4u(");  close = true; break;
            default:
              break;
            }
          }
          if (dMember.type == member.type) {
            shaderSource.append("vertexIn.");
            shaderSource.append(member.name);
          }
          else{
            LOG_WARNING(logger, "%s Skip transfer of %s. (Different types).", sourceDefinition.loadPath.c_str(), member.name.c_str());
          }
          if (close) shaderSource.append(1, ')');
          shaderSource.append(";\n");
          break;
        }
      }
    }
    shaderSource.append("}\n");
  }
 
  bool addOutputStruct(std::string& source, const std::vector<EffectOutputMemberDefinition> outputDefinition, const std::vector<std::pair<std::string, std::string>>& definitions, bool depthOnly) {
    bool outputDepth = false;
    bool hasColorAttachments = !outputDefinition.empty() && !depthOnly;
 
    std::string targetString = "COGS_CUSTOM_DEPTH_WRITE";
    auto it = std::find_if(definitions.begin(), definitions.end(),
      [&targetString](const std::pair<std::string, std::string>& p){
          return p.first == targetString;
      });
 
    if (it != definitions.end()) {
      outputDepth = it->second != "0";
    }
 
    if (!outputDepth && !hasColorAttachments) {
      return false;
    }
 
    source.append("struct FragmentOut {\n");
 
    if (hasColorAttachments) {
      for (auto member : outputDefinition) {
        source.append("  @location(");
        source.append(std::to_string(member.target));
        source.append(") ");
        source.append(member.name + " : ");
 
        switch (member.dataType) {
        case MaterialDataType::Float:     source.append("f32"); break;
        case MaterialDataType::Float2:    source.append("vec2f"); break;
        case MaterialDataType::Float3:    source.append("vec3f"); break;
        case MaterialDataType::Float4:    source.append("vec4f"); break;
        case MaterialDataType::Float4x4:  source.append("mat4x4f"); break;
        case MaterialDataType::Int:       source.append("i32"); break;
        case MaterialDataType::Int2:      source.append("vec2i"); break;
        case MaterialDataType::Int3:      source.append("vec3i"); break;
        case MaterialDataType::Int4:      source.append("vec4i"); break;
        case MaterialDataType::UInt:      source.append("u32"); break;
        case MaterialDataType::UInt2:     source.append("vec2u"); break;
        case MaterialDataType::UInt3:     source.append("vec3u"); break;
        case MaterialDataType::UInt4:     source.append("vec4u"); break;
        default:
          break;
        }
        source.append(",\n");
      }
    }
    if (outputDepth) {
      source.append("@builtin(frag_depth) depth : f32\n");
    }
    source.append("};\n");
    return true;
  }
 
 
  void addCallFunction(std::string& source, std::string_view name, std::string_view functionName, std::string_view inType, std::string_view outType) {
    source.append("fn ");
    source.append(name);
    source.append("(In : ");
    source.append(inType);
    source.append(") ->");
    source.append(outType);
    source.append(" { \n");
    source.append("  return ");
    source.append(functionName);
    source.append("(In);\n");
    source.append("}\n\n");
  }
 
  [[nodiscard]]
  std::string textureDataType(const MaterialDataType type)
  {
    switch (type) {
    case MaterialDataType::Unknown: // Defaults to f32
    case MaterialDataType::Float:;
    case MaterialDataType::Float2:
    case MaterialDataType::Float3:
    case MaterialDataType::Float4:
      return "f32"; break;
    case MaterialDataType::Int:
    case MaterialDataType::Int2:
    case MaterialDataType::Int3:
    case MaterialDataType::Int4:
      return "i32"; break;
    case MaterialDataType::UInt:
    case MaterialDataType::UInt2:
    case MaterialDataType::UInt3:
    case MaterialDataType::UInt4:
      return "u32"; break;
    default:
      LOG_ERROR(logger, "Unsupported texture datatype %d", int(type));
      return "<illegal>";
      break;
    }
  }
 
 
  void addTextures(std::string& shaderSource, const std::unordered_set<Cogs::Core::StringRef>& identifiersSeen, WebGPUBindingGroupVector& bindingGroups, const std::vector<MaterialTextureDefinition>& definition, bool ignoreIdentifiersSeen = false)
  {
    for (auto& texture : definition) {
      if (!identifiersSeen.contains(Strings::add(texture.name)) && !ignoreIdentifiersSeen) {
        continue;
      }
 
      std::string samplerType = "sampler";
 
      std::string type;
      type.reserve(50);
      type += "texture";
 
      if (texture.isDepth) {
        type += "_depth";
        samplerType += "_comparison";
      }
 
      switch (texture.dimensions) {
      case TextureDimensions::Texture2D:
        type += "_2d";
        break;
      case TextureDimensions::TexureCube:
        type += "_cube";
        break;
      case TextureDimensions::Texture2DArray:
        type += "_2d_array";
        break;
      case TextureDimensions::Texture3D:
        type += "_3d";
        break;
      default:
        LOG_ERROR(logger, "Unsupported texture dimension %d", int(texture.dimensions));
        break;
      }
 
      if (!texture.isDepth) {
        std::string dataType = textureDataType(texture.format);
        type += "<" + dataType + ">";
      }
 
      addUniform(shaderSource, bindingGroups, texture.name, type);
      std::string samplerName = texture.name + "Sampler";
      if (identifiersSeen.contains(Strings::add(samplerName)) && !ignoreIdentifiersSeen) {
        addUniform(shaderSource, bindingGroups, samplerName, samplerType);
      }
    }
  }
 
  void addEngineTextures(std::string& shaderSource, const std::unordered_set<Cogs::Core::StringRef>& identifiersSeen, WebGPUBindingGroupVector& bindingGroups)
  {
    for (auto& texture : engineTextures) {
      if (!identifiersSeen.contains(Strings::add(texture.name))) {
        continue;
      }
      std::string type;
      type.reserve(50);
      std::string samplerType = "sampler";
      type += "texture";
 
      if (texture.isDepthTexture) {
        type += "_depth";
        samplerType += "_comparison";
      }
 
      switch (texture.dimensions) {
      case TextureDimensions::Texture2D:
        type += "_2d";
        break;
      case TextureDimensions::TexureCube:
        type += "_cube";
        break;
      case TextureDimensions::Texture2DArray:
        type += "_2d_array";
        break;
      case TextureDimensions::Texture3D:
        type += "_3d";
        break;
      default:
        LOG_ERROR(logger, "Unsupported texture type %d", int(texture.dimensions));
        break;
      }
      if (!texture.isDepthTexture) {
        type += "<f32>";
      }
      addUniform(shaderSource, bindingGroups, texture.name, type);
      addUniform(shaderSource, bindingGroups, texture.name + "Sampler", samplerType);
    }
  }
 
  void concatUniqueMembers(const ShaderInterfaceDefinition& a, const ShaderInterfaceDefinition& b, ShaderInterfaceDefinition& out) {
    out.members.reserve(a.members.size() + b.members.size());
    out = a;
    for (auto member : b.members) {
      bool found = false;
      for (auto existingMember : a.members) {
        if (member.name == existingMember.name) {
          found = true;
          break;
        }
      }
      if (!found) {
        out.members.push_back(member);
      }
    }
  }
} // anonymous namespace
 
bool Cogs::Core::buildEffectWebGPU(Context* context,
  std::vector<std::pair<std::string, std::string>>& definitions,
  MaterialDefinition& materialDefinition,
  const EnginePermutation& permutation,
  const uint32_t multiViewCount)
{
  if (!materialDefinition.effect.geometryShader.entryPoint.empty()) {
    LOG_ERROR(logger, "%s: Geometry shader not allowed in WebGPU.", materialDefinition.name.c_str());
    return false;
  }
  if (!materialDefinition.effect.hullShader.entryPoint.empty()) {
    LOG_ERROR(logger, "%s: Hull shader not allowed in WebGPU.", materialDefinition.name.c_str());
    return false;
  }
  if (!materialDefinition.effect.domainShader.entryPoint.empty()) {
    LOG_ERROR(logger, "%s: Domain shader not allowed in WebGPU.", materialDefinition.name.c_str());
    return false;
  }
  if (!materialDefinition.effect.computeShader.entryPoint.empty()) {
    LOG_ERROR(logger, "%s: Compute shader not allowed in WebGPU.", materialDefinition.name.c_str());
    return false;
  }
 
  changeSuffix(materialDefinition.effect.vertexShader.customSourcePath, ".hlsl", ".wgsl");
  changeSuffix(materialDefinition.effect.pixelShader.customSourcePath, ".hlsl", ".wgsl");
  std::string prefix = "" + materialDefinition.name;
 
  WebGPUBindingGroupVector bindings;
  createBufferBinding(bindings, materialDefinition);
  createTextureBindings(bindings, materialDefinition);
  createEngineTextureBindings(bindings);
 
  {
    PartialPreprocessor pp;
    std::string vs_header;
    const std::string shaderName = prefix + "VertexShader" + permutation.getDefinition()->name + ".wgsl";
    addEffectDefinesAndStuff(vs_header, definitions, multiViewCount);
    if (!pp.process(context, vs_header)) return false;
    vs_header.swap(pp.processed);
    pp.processed.clear();
 
    std::string vs_body;
 
    {
      ShaderInterfaceDefinition vertexInterface;
      concatUniqueMembers(materialDefinition.effect.vertexShader.shaderInterface, permutation.getDefinition()->vertexInterface, vertexInterface);
      addInterfaceStruct(vs_header, vs_body, "VertexIn", vertexInterface, ShaderInterface::VertexIn);
    }
    {
      ShaderInterfaceDefinition surfaceInterface;
      concatUniqueMembers(materialDefinition.effect.pixelShader.shaderInterface, permutation.getDefinition()->surfaceInterface, surfaceInterface);
      addInterfaceStruct(vs_header, vs_body, "VertexOut", surfaceInterface, ShaderInterface::VertexOut);
    }
    addInterfaceConstructor(vs_body, "VertexOut", materialDefinition.effect.pixelShader.shaderInterface);
    addTransferFunc(vs_body, materialDefinition.effect.vertexShader, materialDefinition.effect.pixelShader);
    addInclude(vs_body, std::string_view(), materialDefinition.effect.vertexShader.customSourcePath);
    std::string permutationVS = permutation.getDefinition()->vertexShader;
    changeSuffix(permutationVS, ".hlsl", ".wgsl");
 
    addCallFunction(vs_body, "callMaterialVertexFunction",
      materialDefinition.effect.vertexShader.entryPoint.empty() ? "vertexFunction" : materialDefinition.effect.vertexShader.entryPoint,
      "VertexIn", "VertexOut");
    addInclude(vs_body, std::string_view(), "Engine/EngineVS.wgsl");
    addCallFunction(vs_body, "callVertexFunction",
      "invokeMaterial",
      "VertexIn", "VertexOut");
    addInclude(vs_body, std::string_view(), permutationVS);
    if (!pp.process(context, vs_body)) return false;
    vs_body.swap(pp.processed);
    pp.processed.clear();
 
    std::string vs_uniforms;
    addTextures(vs_uniforms, pp.identifiersSeen, bindings, materialDefinition.properties.textures, false);
 
    for (const ConstantBufferDefinition& buffer : permutation.getDefinition()->properties.buffers) {
      addUniformBuffer(vs_uniforms, pp.identifiersSeen, buffer, bindings);
    }
    for (const ConstantBufferDefinition& buffer : materialDefinition.properties.buffers) {
      addUniformBuffer(vs_uniforms, pp.identifiersSeen, buffer, bindings);
    }
    addEngineBuffers(vs_uniforms, pp.identifiersSeen, bindings);
    addInclude(vs_uniforms, std::string_view(), "Engine/Common.wgsl");
 
    if (!pp.process(context, vs_uniforms)) return false;
    vs_uniforms.swap(pp.processed);
    pp.processed.clear();
 
    std::string all = vs_header + vs_uniforms + vs_body;
    all = convertDefinesToConstExpressions(all);
 
    std::string vspath = "Shaders/" + shaderName;
    context->resourceStore->addResource(vspath, all);
  }
  {
    PartialPreprocessor pp;
    std::string fs_header;
    const std::string shaderName = prefix + "PixelShader" + permutation.getDefinition()->name + ".wgsl";
    addEffectDefinesAndStuff(fs_header, definitions, 0 /* multiview handled in VS. */);
 
    std::string fs_body;
    bool fs_returnsStruct = false;
    {
      ShaderInterfaceDefinition surfaceInterface = materialDefinition.effect.pixelShader.shaderInterface;
      surfaceInterface.members.insert(surfaceInterface.members.end(), permutation.getDefinition()->surfaceInterface.members.begin(),
        permutation.getDefinition()->surfaceInterface.members.end());
      addInterfaceStruct(fs_header, fs_body, "VertexIn", surfaceInterface, ShaderInterface::FragmentIn);
      fs_returnsStruct = addOutputStruct(fs_header, permutation.getDefinition()->outputs.members, definitions, permutation.isDepthOnly());
    }
 
    addInclude(fs_header, std::string_view(), materialDefinition.effect.pixelShader.customSourcePath);
    std::string permutationFS = permutation.getDefinition()->pixelShader;
    changeSuffix(permutationFS, ".hlsl", ".wgsl");
 
    addCallFunction(fs_header, "callMaterialSurfaceFunction",
      materialDefinition.effect.pixelShader.entryPoint.empty() ? "surfaceFunction" : materialDefinition.effect.pixelShader.entryPoint,
      "VertexIn", "SurfaceOut");
    addInclude(fs_header, std::string_view(), "Engine/EnginePS.wgsl");
    addCallFunction(fs_header, "callSurfaceFunction",
      "invokeMaterial",
      "VertexIn", "SurfaceOut");
    addInclude(fs_header, std::string_view(), permutationFS);
    if (fs_returnsStruct) {
      fs_header.append(
          R"(
@fragment
fn main(In : VertexIn) -> FragmentOut {
  return permutationMain(In);
}
)");
    } else {
      fs_header.append(
        R"(
@fragment
fn main(In : VertexIn) {
  permutationMain(In);
}
)");
 
    }
    if (!pp.process(context, fs_header)) return false;
    fs_header.swap(pp.processed);
    pp.processed.clear();
 
    std::string fs_uniforms;
    fs_uniforms.reserve(InitialBufferCapasity);
    addTextures(fs_uniforms, pp.identifiersSeen, bindings, materialDefinition.properties.textures, false);
    addEngineTextures(fs_uniforms, pp.identifiersSeen, bindings);
    for (const ConstantBufferDefinition& buffer : permutation.getDefinition()->properties.buffers) {
      addUniformBuffer(fs_uniforms, pp.identifiersSeen, buffer, bindings);
    }
    for (const ConstantBufferDefinition& buffer : materialDefinition.properties.buffers) {
      addUniformBuffer(fs_uniforms, pp.identifiersSeen, buffer, bindings);
    }
    addEngineBuffers(fs_uniforms, pp.identifiersSeen, bindings);
    addInclude(fs_uniforms, std::string_view(), "Engine/Common.wgsl");
    if (!pp.process(context, fs_uniforms)) return false;
    fs_uniforms.swap(pp.processed);
    pp.processed.clear();
 
    std::string all = fs_header + fs_uniforms + fs_body;
    all = convertDefinesToConstExpressions(all);
 
    std::string fspath = "Shaders/" + shaderName;
    context->resourceStore->addResource(fspath, all);
  }
  definitions.clear();
  return true;
}