ShaderBuilderWebGPU.cpp

#include "ShaderBuilder.h"
#include "ShaderBuilderHelpersWebGPU.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;
  using Cogs::BindGroupDescription;
  using Cogs::BindGroupEntryDescription;
  using Cogs::BindGroupSetDescription;
  using Cogs::BindingResourceType;
  using Cogs::ResourceDimensions;
  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}},
  };
 
 
  [[nodiscard]]
  Cogs::BindGroupDescription& getOrCreateGroup(Cogs::BindGroupSetDescription& layoutSet, const uint16_t groupIndex)
  {
    if (layoutSet.numGroups <= groupIndex) {
      layoutSet.numGroups = groupIndex + 1;
    }
    return layoutSet.groups[groupIndex];
  }
 
  [[nodiscard]]
  BindGroupEntryDescription* findEntry(BindGroupDescription& group, size_t nameHash)
  {
    for (uint16_t i = 0; i < group.numEntries; ++i) {
      if (group.entries[i].nameHash == nameHash) {
        return &group.entries[i];
      }
    }
    return nullptr;
  }
 
  [[nodiscard]]
  BindGroupEntryDescription* findEntry(BindGroupDescription& group, std::string_view name)
  {
    return findEntry(group, Cogs::hash(name));
  }
 
  [[nodiscard]]
  size_t nextBindingIndex(const BindGroupDescription& group)
  {
    size_t nextBinding = 0;
    for (uint16_t i = 0; i < group.numEntries; ++i) {
      nextBinding = std::max(nextBinding, size_t(group.entries[i].binding) + 1);
    }
    return nextBinding;
  }
 
  [[nodiscard]]
  BindGroupEntryDescription* claimEntry(BindGroupDescription& group, std::string_view name)
  {
    if (group.numEntries >= Cogs::MaxBindGroupEntries) {
      LOG_ERROR(logger, "Bind group is full (%d entries), dropping binding %s", int(Cogs::MaxBindGroupEntries), std::string(name).c_str());
      return nullptr;
    }
    const uint32_t binding = static_cast<uint32_t>(nextBindingIndex(group));
    BindGroupEntryDescription& entry = group.entries[group.numEntries++];
    entry = BindGroupEntryDescription{};
    entry.binding = binding;
    entry.nameHash = Cogs::hash(name);
    return &entry;
  }
 
 
  ResourceDimensions bindingLayoutTextureDimension(const Cogs::Core::TextureDimensions dimensions)
  {
    switch (dimensions) {
    case Cogs::Core::TextureDimensions::Texture2D: return ResourceDimensions::Texture2D;
    case Cogs::Core::TextureDimensions::Texture2DArray: return ResourceDimensions::Texture2DArray;
    case Cogs::Core::TextureDimensions::Texture3D: return ResourceDimensions::Texture3D;
    case Cogs::Core::TextureDimensions::TexureCube: return ResourceDimensions::TextureCube;
    default: return ResourceDimensions::Unknown;
    }
  }
 
 
 
  [[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 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 {
          if (attribute.modifiers & ShaderInterfaceMemberDefinition::NointerpolationModifier) {
            source.append("  @interpolate(flat)");
          }
          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,
                  BindGroupSetDescription& layoutSet,
                  int group,
                  uint32_t visibility,
                  std::string_view name,
                  std::string_view type,
                  bool useTemplate = false,
                  BindingResourceType resourceType = BindingResourceType::UniformBuffer,
                  ResourceDimensions textureDimension = ResourceDimensions::Unknown,
                  bool isDepthTexture = false) {
    BindGroupDescription& bindings = getOrCreateGroup(layoutSet, static_cast<uint16_t>(group));
    BindGroupEntryDescription* entry = findEntry(bindings, name);
    if (!entry) {
      entry = claimEntry(bindings, name);
      if (!entry) return;
      entry->resourceType = resourceType;
      entry->textureDimension = textureDimension;
      entry->isDepthTexture = isDepthTexture;
    }
    // The same uniform may be emitted for several stages; accumulate the stages that reference it.
    entry->visibility |= visibility;
 
    shaderSource.append("@group(");
    shaderSource.append(std::to_string(group));
    shaderSource.append(") @binding(");
    shaderSource.append(std::to_string(entry->binding));
    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, BindGroupSetDescription& layoutSet, int group, uint32_t visibility)
  {
    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, layoutSet, group, visibility, definition.name, definition.name + "_t", true);
  }
 
  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;
    }
  }
 
  [[nodiscard]]
  Cogs::BindingTextureSampleType deduceTextureSampleType(const MaterialDataType type, const bool isDepthTexture, const bool multisampled)
  {
    if (isDepthTexture) {
      return Cogs::BindingTextureSampleType::Depth;
    }
 
    switch (type) {
    case MaterialDataType::Int:
    case MaterialDataType::Int2:
    case MaterialDataType::Int3:
    case MaterialDataType::Int4:
      return Cogs::BindingTextureSampleType::Sint;
    case MaterialDataType::UInt:
    case MaterialDataType::UInt2:
    case MaterialDataType::UInt3:
    case MaterialDataType::UInt4:
      return Cogs::BindingTextureSampleType::Uint;
    default:
      return multisampled
        ? Cogs::BindingTextureSampleType::UnfilterableFloat
        : Cogs::BindingTextureSampleType::Float;
    }
  }
 
  [[nodiscard]]
  Cogs::BindingSamplerBindingType deduceSamplerBindingType(const MaterialDataType type, const bool isDepthTexture, const bool multisampled)
  {
    if (isDepthTexture) {
      return Cogs::BindingSamplerBindingType::Comparison;
    }
 
    switch (type) {
    case MaterialDataType::Int:
    case MaterialDataType::Int2:
    case MaterialDataType::Int3:
    case MaterialDataType::Int4:
    case MaterialDataType::UInt:
    case MaterialDataType::UInt2:
    case MaterialDataType::UInt3:
    case MaterialDataType::UInt4:
      return Cogs::BindingSamplerBindingType::NonFiltering;
    default:
      return multisampled
        ? Cogs::BindingSamplerBindingType::NonFiltering
        : Cogs::BindingSamplerBindingType::Filtering;
    }
  }
 
 
  void addTextures(std::string& shaderSource, const std::unordered_set<Cogs::Core::StringRef>& identifiersSeen, BindGroupSetDescription& layoutSet, int group, uint32_t visibility, 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 + ">";
      }
 
      ResourceDimensions textureDimension = bindingLayoutTextureDimension(texture.dimensions);
      const bool multisampled = false; // MaterialTextureDefinition does not expose sample count.
      addUniform(shaderSource, layoutSet, group, visibility, texture.name, type, false, BindingResourceType::Texture, textureDimension, texture.isDepth);
      {
        BindGroupDescription& bindGroup = getOrCreateGroup(layoutSet, static_cast<uint16_t>(group));
        BindGroupEntryDescription* textureEntry = findEntry(bindGroup, texture.name);
        if (textureEntry) {
          textureEntry->textureSampleType = deduceTextureSampleType(texture.format, texture.isDepth, multisampled);
          textureEntry->multisampled = multisampled;
        }
      }
      std::string samplerName = texture.name + "Sampler";
      if (identifiersSeen.contains(Strings::add(samplerName)) && !ignoreIdentifiersSeen) {
        addUniform(shaderSource, layoutSet, group, visibility, samplerName, samplerType, false, BindingResourceType::Sampler, textureDimension, texture.isDepth);
        BindGroupDescription& bindGroup = getOrCreateGroup(layoutSet, static_cast<uint16_t>(group));
        BindGroupEntryDescription* samplerEntry = findEntry(bindGroup, samplerName);
        if (samplerEntry) {
          samplerEntry->samplerBindingType = deduceSamplerBindingType(texture.format, texture.isDepth, multisampled);
        }
      }
    }
  }
 
  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;
 
  BindGroupSetDescription bindings;
  bindings = getEngineBindGroupDescription();
  std::vector<bool> bindGroupUsed(static_cast<size_t>(Cogs::Core::BindGroup::Count), false);
 
  {
    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, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityVertex, materialDefinition.properties.textures, false);
 
    for (const ConstantBufferDefinition& buffer : permutation.getDefinition()->properties.buffers) {
      addUniformBuffer(vs_uniforms, pp.identifiersSeen, buffer, bindings, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityVertex);
    }
    for (const ConstantBufferDefinition& buffer : materialDefinition.properties.buffers) {
      addUniformBuffer(vs_uniforms, pp.identifiersSeen, buffer, bindings, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityVertex);
    }
    addEngineUniformsToSourceWebGPU(vs_uniforms, pp.identifiersSeen, bindGroupUsed);
 
    // AnimationBuffer is only referenced by skinned permutations (see StandardMaterialVS.wgsl's
    // COGS_VARIANT_SKINNED_BASIC branch), so only claim a bind group entry for it when the vertex
    // body actually used it. Adding it unconditionally would force every non-skinned draw to bind
    // a buffer its shader never declares.
    if (pp.identifiersSeen.contains(Strings::add("AnimationBuffer"))) {
      addInclude(vs_uniforms, std::string_view(), "Engine/AnimationBuffer.wgsl");
      addUniform(vs_uniforms, bindings, static_cast<int>(Cogs::Core::BindGroup::Object), Cogs::BindingVisibilityVertex, "AnimationBuffer", "AnimationBuffer_t", true);
      bindGroupUsed[static_cast<size_t>(Cogs::Core::BindGroup::Object)] = true;
    }
 
    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, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityFragment, materialDefinition.properties.textures, false);
    addEngineUniformsToSourceWebGPU(fs_uniforms, pp.identifiersSeen, bindGroupUsed);
    for (const ConstantBufferDefinition& buffer : permutation.getDefinition()->properties.buffers) {
      addUniformBuffer(fs_uniforms, pp.identifiersSeen, buffer, bindings, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityFragment);
    }
    for (const ConstantBufferDefinition& buffer : materialDefinition.properties.buffers) {
      addUniformBuffer(fs_uniforms, pp.identifiersSeen, buffer, bindings, static_cast<int>(Cogs::Core::BindGroup::Default), Cogs::BindingVisibilityFragment);
    }
    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);
  }
  
  // Export the bind groups that were actually referenced.
  // The Default group holds this material's own bindings and is never flagged by the engine helper.
  bindGroupUsed[static_cast<size_t>(Cogs::Core::BindGroup::Default)] = bindings.groups[0].numEntries > 0;
  materialDefinition.effect.bindGroupLayouts.numGroups = 0;
  for (size_t g = 0; g < bindGroupUsed.size(); g++) {
    BindGroupDescription& target = materialDefinition.effect.bindGroupLayouts.groups[g];
    target.numEntries = 0;
    if (!bindGroupUsed[g]) continue;
 
    // Copied verbatim: engine bind groups are shared across effects and must stay identical, so
    // entries keep their slots even when no stage references them. Dropping them would renumber
    // the remainder and make otherwise-equal groups compare unequal.
    target = bindings.groups[g];
    materialDefinition.effect.bindGroupLayouts.numGroups = static_cast<uint16_t>(g + 1);
  }
  
  definitions.clear();
  return true;
}