EffectsWebGPU.cpp

#include "EffectsWebGPU.h"
 
#include "GraphicsDeviceWebGPU.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
#include <cinttypes>
#include <sstream>
#include <regex>
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsWebGPU");
 
  bool starts_with(std::string::const_iterator begin, std::string::const_iterator end, const char* s, std::string::const_iterator& next) {
    std::string::const_iterator it = begin;
    next = begin;
    while (it != end && *s != '\0') {
      if (*it != *s) {
        return false;
      }
      s++;
      it++;
    }
    if (*s != '\0') {
      return false;
    }
    next = it;
    return true;
  }
 
  void eat_white(std::string::const_iterator& it, std::string::const_iterator end) {
    while (it != end && std::isspace(*it)) {
      it++;
    }
  }
 
  WGPUTextureViewDimension extractViewDimention(std::string::const_iterator& type_it, std::string::const_iterator end) {
    WGPUTextureViewDimension tvd = WGPUTextureViewDimension_Undefined;
    if (starts_with(type_it, end, "2d_array", type_it)) {
      tvd = WGPUTextureViewDimension_2DArray;
    }
    else if (starts_with(type_it, end, "2d", type_it)) {
      tvd = WGPUTextureViewDimension_2D;
    }
    else if (starts_with(type_it, end, "cube", type_it)) {
      tvd = WGPUTextureViewDimension_Cube;
    }
    else if (starts_with(type_it, end, "1d", type_it)) {
      tvd = WGPUTextureViewDimension_1D;
    }
    else if (starts_with(type_it, end, "cube_array", type_it)) {
      tvd = WGPUTextureViewDimension_CubeArray;
    }
    else if (starts_with(type_it, end, "3d", type_it)) {
      tvd = WGPUTextureViewDimension_3D;
    }
    return tvd;
  }
 
  WGPUTextureFormat extractTextureFormat(std::string::const_iterator& type_it, std::string::const_iterator end) {
    WGPUTextureFormat tf = WGPUTextureFormat_Undefined;
    if (starts_with(type_it, end, "rgba8unorm", type_it)) {
      tf = WGPUTextureFormat_RGBA8Unorm;
    }
    else if (starts_with(type_it, end, "rgba8snorm", type_it)) {
      tf = WGPUTextureFormat_RGBA8Snorm;
    }
    else if (starts_with(type_it, end, "rgba8uint", type_it)) {
      tf = WGPUTextureFormat_RGBA8Uint;
    }
    else if (starts_with(type_it, end, "rgba8sint", type_it)) {
      tf = WGPUTextureFormat_RGBA8Sint;
    }
    else if (starts_with(type_it, end, "rgba16uint", type_it)) {
      tf = WGPUTextureFormat_RGBA16Uint;
    }
    else if (starts_with(type_it, end, "rgba16sint", type_it)) {
      tf = WGPUTextureFormat_RGBA16Sint;
    }
    else if (starts_with(type_it, end, "rgba16float", type_it)) {
      tf = WGPUTextureFormat_RGBA16Float;
    }
    else if (starts_with(type_it, end, "r32uint", type_it)) {
      tf = WGPUTextureFormat_R32Uint;
    }
    else if (starts_with(type_it, end, "r32sint", type_it)) {
      tf = WGPUTextureFormat_R32Sint;
    }
    else if (starts_with(type_it, end, "r32float", type_it)) {
      tf = WGPUTextureFormat_R32Float;
    }
    else if (starts_with(type_it, end, "rg32uint", type_it)) {
      tf = WGPUTextureFormat_RG32Uint;
    }
    else if (starts_with(type_it, end, "rg32sint", type_it)) {
      tf = WGPUTextureFormat_RG32Sint;
    }
    else if (starts_with(type_it, end, "rg32float", type_it)) {
      tf = WGPUTextureFormat_RG32Float;
    }
    else if (starts_with(type_it, end, "rgba32uint", type_it)) {
      tf = WGPUTextureFormat_RGBA32Uint;
    }
    else if (starts_with(type_it, end, "rgba32sint", type_it)) {
      tf = WGPUTextureFormat_RGBA32Sint;
    }
    else if (starts_with(type_it, end, "rgba32float", type_it)) {
      tf = WGPUTextureFormat_RGBA32Float;
    }
    else if (starts_with(type_it, end, "bgra8unorm", type_it)) {
      tf = WGPUTextureFormat_BGRA8Unorm;
    }
    return tf;
  }
 
  WGPUStorageTextureAccess extractStorageTextureAccess(std::string::const_iterator& type_it, std::string::const_iterator end) {
    WGPUStorageTextureAccess  sta = WGPUStorageTextureAccess_Undefined;
    if (starts_with(type_it, end, "read", type_it)) {
      sta = WGPUStorageTextureAccess_ReadOnly;
    }
    else if (starts_with(type_it, end, "write", type_it)) {
      sta = WGPUStorageTextureAccess_WriteOnly;
    }
    else if (starts_with(type_it, end, "readwrite", type_it)) {
      sta = WGPUStorageTextureAccess_ReadWrite;
    }
    return sta;
  }
 
  std::vector<Cogs::WebGPUConstantBufferBinding> extractConstantBindingLayout(std::string shaderSource, WGPUShaderStage usage) {
    std::vector<Cogs::WebGPUConstantBufferBinding> result;
    std::istringstream iss(shaderSource);
    std::string expr = R"(^\s*@group\‍(([0-9]+)\) @binding\‍(([0-9]+)\)\s+var(<uniform>)?\s+([^\s]+)[\s]*:\s?(.*)\s?;)";
    std::regex regex_expression(expr);
 
    for (std::string line; std::getline(iss, line); )
    {
      std::smatch match;
      if (std::regex_search(line, match, regex_expression))
      {
        size_t group = std::stoi(match.str(1));
        unsigned int loc = std::stoi(match.str(2));
        bool isUniform = match.str(3) == "<uniform>";
        std::string name = match.str(4);
        std::string type = match.str(5);
 
        std::string::const_iterator type_it = type.begin();
        size_t nameHash = Cogs::hash(name);
        // Cogs::ConstantBufferBindingHandle location = (Cogs::ConstantBufferBindingHandle)loc;
        // Cogs::WebGPUConstantBufferType bufferType = Cogs::WebGPUConstantBufferType::UniformBuffer;
        bool alreadyInserted = false;
        for (auto& e : result) {
          if (e.group == group && e.bg_ent.binding == loc) {
            e.bg_ent.visibility |= usage;
            alreadyInserted = true;
            break;
          }
        }
        if (alreadyInserted) {
          continue;
        }
        WGPUBindGroupLayoutEntry bg_ent = WGPU_BIND_GROUP_LAYOUT_ENTRY_INIT;
        bg_ent.binding = static_cast<uint32_t>(loc);
        bg_ent.visibility = (WGPUShaderStage)usage;
 
        if (isUniform) {
          bg_ent.buffer.type = WGPUBufferBindingType_Uniform;
          // bufferType = Cogs::WebGPUConstantBufferType::UniformBuffer;
        }
        else if (starts_with(type_it, type.end(), "texture_storage_", type_it)) { //  type.starts_with("texture_")
          bg_ent.storageTexture.viewDimension = extractViewDimention(type_it, type.end());
          eat_white(type_it, type.end());
          if (!starts_with(type_it, type.end(), "<", type_it)) {
            LOG_DEBUG(logger, "Texture type %s not yet supported", type.c_str());
          }
          bg_ent.storageTexture.format = extractTextureFormat(type_it, type.end());
          eat_white(type_it, type.end());
          if (!starts_with(type_it, type.end(), ",", type_it)) {
            LOG_DEBUG(logger, "Texture type %s not yet supported", type.c_str());
          }
          eat_white(type_it, type.end());
          bg_ent.storageTexture.access = extractStorageTextureAccess(type_it, type.end());
          eat_white(type_it, type.end());
          if (!starts_with(type_it, type.end(), ">", type_it)) {
            LOG_DEBUG(logger, "Texture type %s not yet supported", type.c_str());
          }
        }
        else if (starts_with(type_it, type.end(), "texture_", type_it)) { 
          bool isDepth = false;
          bool isMS = false;
          // bufferType = Cogs::WebGPUConstantBufferType::Texture;
          bg_ent.texture.sampleType = WGPUTextureSampleType_Float;
          bg_ent.texture.viewDimension = WGPUTextureViewDimension_2D;
          bg_ent.texture.multisampled = 0;
          if (starts_with(type_it, type.end(), "depth_", type_it)) {
            isDepth = true;
          }
          if (starts_with(type_it, type.end(), "multisampled_", type_it)) {
            bg_ent.texture.multisampled = 1;
            isMS = true;
          }
          bg_ent.texture.viewDimension = extractViewDimention(type_it, type.end());
          eat_white(type_it, type.end());
          if (isDepth) {
            bg_ent.texture.sampleType = WGPUTextureSampleType_Depth;
          } else if (starts_with(type_it, type.end(), "<f32>", type_it)) {
            if(isMS) {
              bg_ent.texture.sampleType = WGPUTextureSampleType_UnfilterableFloat;
            } else {
              bg_ent.texture.sampleType = WGPUTextureSampleType_Float;
            }
          }
          else if (starts_with(type_it, type.end(), "<i32>", type_it)) {
            bg_ent.texture.sampleType = WGPUTextureSampleType_Sint;
          }
          else if (starts_with(type_it, type.end(), "<u32>", type_it)) {
            bg_ent.texture.sampleType = WGPUTextureSampleType_Uint;
          }
          else {
            LOG_DEBUG(logger, "Texture type %s not yet supported", type.c_str());
          }
        }
        else if (type == "sampler") {
          // bufferType = Cogs::WebGPUConstantBufferType::Sampler;
          bg_ent.sampler.type = WGPUSamplerBindingType_Filtering;
        }
        else if (type == "sampler_comparison") {
          // bufferType = Cogs::WebGPUConstantBufferType::Sampler;
          bg_ent.sampler.type = WGPUSamplerBindingType_Comparison;
        }
        else {
          LOG_DEBUG(logger, "Unknown uniform type%s", type.c_str());
        }
 
        Cogs::WebGPUConstantBufferBinding binding{.group = group, .nameHash = nameHash, .bg_ent = bg_ent, .name = name };
        result.push_back(binding);
      }
    }
    return result;
  }
 
  const char* semanticNames[]
  {
    "a_POSITION",
    "a_NORMAL",
    "a_COLOR",
    "a_TEXCOORD",
    "a_TANGENT",
    "a_INSTANCEVECTOR",
    "a_INSTANCEMATRIX",
  };
 
  WGPUVertexFormat stringToVertexFormat(const Cogs::StringView &s) {
    WGPUVertexFormat format = static_cast<WGPUVertexFormat>(0);
    switch (Cogs::hash(s))
    {
    case Cogs::hash("f32"): format = WGPUVertexFormat::WGPUVertexFormat_Float32;     break;
    case Cogs::hash("vec2f"): format = WGPUVertexFormat::WGPUVertexFormat_Float32x2;   break;
    case Cogs::hash("vec3f"): format = WGPUVertexFormat::WGPUVertexFormat_Float32x3;   break;
    case Cogs::hash("vec4f"): format = WGPUVertexFormat::WGPUVertexFormat_Float32x4;   break;
    case Cogs::hash("i32"):   format = WGPUVertexFormat::WGPUVertexFormat_Sint32;      break;
    case Cogs::hash("vec2i"): format = WGPUVertexFormat::WGPUVertexFormat_Sint32x2;    break;
    case Cogs::hash("vec3i"): format = WGPUVertexFormat::WGPUVertexFormat_Sint32x3;    break;
    case Cogs::hash("vec4i"): format = WGPUVertexFormat::WGPUVertexFormat_Sint32x4;    break;
    case Cogs::hash("u32"):   format = WGPUVertexFormat::WGPUVertexFormat_Uint32;      break;
    case Cogs::hash("vec2u"): format = WGPUVertexFormat::WGPUVertexFormat_Uint32x2;    break;
    case Cogs::hash("vec3u"): format = WGPUVertexFormat::WGPUVertexFormat_Uint32x3;    break;
    case Cogs::hash("vec4u"): format = WGPUVertexFormat::WGPUVertexFormat_Uint32x4;    break;
    default:
      LOG_ERROR(logger, "Unsupported vertex attribute type %s", std::string(s).c_str());
      break;
    }
    return format;
  }
 
  // size_t extractVertexAttribLocation_old(std::string shaderSource, Cogs::SemanticSlotBinding bindings[], size_t /*maxBindings*/) {
  //   std::istringstream iss(shaderSource);
  //   std::string expr = R"(\s*const ([^\s^0-9]+)([0-9]+)_LOC\s*=\s*([0-9]+))";
  //   std::regex regex_expression(expr);
  //   size_t nAttribs = 0;
  //   for (std::string line; std::getline(iss, line); )
  //   {
  //     std::smatch match;
  //     if (std::regex_search(line, match, regex_expression))
  //     {
  //       std::string semanticName = match.str(1);
  //       uint8_t slot = static_cast<uint8_t>(std::stoi(match.str(2)));
  //       uint8_t loc = static_cast<uint8_t>(std::stoi(match.str(3)));
  //       for (uint8_t i = 0; i < std::size(semanticNames); i++) {
  //         if (strcmp(semanticName.c_str(), semanticNames[i]) == 0) {
  //           Cogs::SemanticSlotBinding& b = bindings[nAttribs++];
  //           b.semantic = i;
  //           b.slot = slot;
  //           b.binding = loc;
  //           break;
  //         }
  //       }
  //     }
  //   }
  //   return nAttribs;
  // }
 
  size_t extractVertexAttribLocation(std::string shaderSource, Cogs::SemanticSlotBinding bindings[], size_t /*maxBindings*/) {
    std::istringstream iss(shaderSource);
    std::string expr = R"(\s*const ([^\s^0-9]+)([0-9]+)_LOC\s*=\s*([0-9]+))";
    std::regex regex_expression(expr);
    size_t nAttribs = 0;
    for (std::string line; std::getline(iss, line); )
    {
      std::smatch match;
      if (std::regex_search(line, match, regex_expression))
      {
        std::string semanticName = match.str(1);
        uint8_t slot = static_cast<uint8_t>(std::stoi(match.str(2)));
        uint8_t loc = static_cast<uint8_t>(std::stoi(match.str(3)));
        for (uint8_t i = 0; i < std::size(semanticNames); i++) {
          if (strcmp(semanticName.c_str(), semanticNames[i]) == 0) {
            Cogs::SemanticSlotBinding& b = bindings[nAttribs++];
            b.semantic = i;
            b.slot = slot;
            b.binding = loc;
            break;
          }
        }
      }
    }
 
    iss.clear();
    iss.seekg(0, std::ios::beg);
    std::string expr_location = R"(@location\‍(\s*([^\s\)\d]+)([\d]+)_LOC\s*\)\s*([^\s:]+)\s*:\s*([\da-zA-Z]+)[,\s\n])";
    std::regex regex_location(expr_location);
    for (std::string line; std::getline(iss, line); )
    {
      std::smatch match;
      if (std::regex_search(line, match, regex_location))
      {
        std::string semanticName = match.str(1);
        uint8_t slot = static_cast<uint8_t>(std::stoi(match.str(2)));
        std::string name = match.str(3);
        std::string type = match.str(4);
        uint8_t semantic = std::numeric_limits<uint8_t>::max();
        for (uint8_t i = 0; i < std::size(semanticNames); i++) {
          if (strcmp(semanticName.c_str(), semanticNames[i]) == 0) {
            semantic = i;
            break;
          }
        }
        if (semantic == std::numeric_limits<uint8_t>::max()) {
          LOG_DEBUG(logger, "unknown semantic name for vertex attribute %s", semanticName.c_str());
          continue;
        }
        for (size_t i = 0; i < nAttribs; i++) {
          if (bindings[i].semantic == semantic && bindings[i].slot == slot) {
            bindings[i].format = stringToVertexFormat(Cogs::StringView(type));
            bindings[i].nameHash = Cogs::hash(name);
            break;
          }
        }
      }
    }
    return nAttribs;
  }
 
  Cogs::ConstantBufferBindingHandle encodeConstantBufferBindingHandle(Cogs::WebGPUConstantBufferBinding binding) {
    size_t i = (binding.group << 16) + (binding.bg_ent.binding + 1 );
    return (Cogs::ConstantBufferBindingHandle) i;
  }
 
  void dumpSource(const std::string& source, int firstLine = 1, int lastLine = std::numeric_limits<int>::max())
  {
    const char* start = source.data();
    const char* curr = start;
    int line = 1;
 
    while ((*curr != '\0') && (line <= lastLine)) {
      const char* p = curr;
      while ((*p != '\0') && (*p != '\n') && (*p != '\r')) { p++; }
 
      if (firstLine <= line) {
        LOG_DEBUG(logger, "%3d: %s", line, std::string(curr, p - curr).c_str());
      }
 
      line = line + 1;
 
      curr = p;
      if (*curr != '\0') { curr++; };
      if ((*curr != '\0') && (*curr != *p) && ((*curr == '\n') || (*curr == '\r'))) { curr++; }
    }
  }
 
  void printShaderError(struct WGPUCompilationInfo const* compilationInfo, const std::string* source = nullptr)
  {
    for (size_t i = 0; i < compilationInfo->messageCount; i++) {
      const WGPUCompilationMessage& message = compilationInfo->messages[i];
      if (source) {
        dumpSource(*source, ((int)message.lineNum) - 3, ((int)message.lineNum));
      }
      Cogs::Logging::Category category;
      std::string category_str;
      switch (message.type) {
      case WGPUCompilationMessageType::WGPUCompilationMessageType_Info:
        category = Cogs::Logging::Category::Info;
        category_str = "Info";
        break;
      case WGPUCompilationMessageType::WGPUCompilationMessageType_Error:
        category = Cogs::Logging::Category::Error;
        category_str = "Error";
        break;
      case WGPUCompilationMessageType::WGPUCompilationMessageType_Force32:
        category = Cogs::Logging::Category::Error;
        category_str = "Force32";
        break;
      default:
        category = Cogs::Logging::Category::Error;
        category_str = "Unknown";
      }
 
      logger.log(category, Cogs::Logging::ErrorGroup::Unspecified, "WGSL %s (%" PRIu64 ", %" PRIu64 "): %.*s", category_str.c_str(), message.lineNum, message.linePos, WGPUStringViewFormat(message.message));
    }
  }
 
  void compile_callback(WGPUCompilationInfoRequestStatus status, struct WGPUCompilationInfo const* compilationInfo, void* userdata1, void* /* userdata2 */) // Does not seem to be called if the shader does not compile
  {
    const std::string* source = reinterpret_cast<std::string*>(userdata1);
    if (status != WGPUCompilationInfoRequestStatus_Success || (compilationInfo != nullptr && compilationInfo->messageCount != 0))
    {
      if(status == WGPUCompilationInfoRequestStatus_CallbackCancelled){
        LOG_INFO(logger, "WGPUCompilationInfoRequestStatus_CallbackCancelled");
      }
      if(compilationInfo){
        printShaderError(compilationInfo, source);
      }
    }
  }
}
 
namespace Cogs{
  void EffectsWebGPU::initialize(GraphicsDeviceWebGPU *device_in, IBuffers * buffers_in)
  {
    EffectsCommon::initialize(buffers_in);
    graphicsDevice = device_in;
  }
 
  void EffectsWebGPU::releaseResources()
  {
  }
 
  void EffectsWebGPU::releaseEffect(EffectHandle handle)
  {
    if (!HandleIsValid(handle)) return;
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    EffectWebGPU &effect = this->effects[handle];
    wgpuShaderModuleRelease(effect.vs_module);
    counters.shader_module--;
    wgpuShaderModuleRelease(effect.fs_module);
    counters.shader_module--;
    this->effects.removeResource(handle);
  }
 
  EffectHandle EffectsWebGPU::loadComputeEffect(const StringView& fileName, EffectFlags::EEffectFlags effectFlags)
  {
    PreprocessorDefinitions defines = {};
    return loadComputeEffect(fileName, defines, effectFlags);
  }
 
  EffectHandle EffectsWebGPU::loadComputeEffect(const StringView& fileName, const PreprocessorDefinitions& definitions, EffectFlags::EEffectFlags effectFlags)
  {
    WGPUDevice device = graphicsDevice->device;
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
 
    ProcessedContent csSource;
    Utilities::readFile(handler, fileName, csSource);
 
    EffectWebGPU effect = {};
    effect.cs_entry = "main";
    effect.name = std::string(fileName);
 
    std::string cs_source;
    for(auto &def : definitions){
      cs_source += "const " + def.first + " = " + def.second + ";\n";
    }
    cs_source += csSource.content;
 
    if ((effectFlags & Cogs::EffectFlags::EEffectFlags::LogShaderSource) == Cogs::EffectFlags::EEffectFlags::LogShaderSource) {
      LOG_INFO(logger, "Compiling WebGPU CS:\n%s", cs_source.c_str());
    }
 
    WGPUShaderModuleDescriptor descriptor = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
    descriptor.label = {fileName.data(), WGPU_STRLEN};
    WGPUShaderSourceWGSL wgsl_desc = WGPU_SHADER_SOURCE_WGSL_INIT;
    wgsl_desc.chain.sType = WGPUSType_ShaderSourceWGSL;
    wgsl_desc.code = {cs_source.c_str(), WGPU_STRLEN};
    descriptor.nextInChain = (WGPUChainedStruct*)&wgsl_desc;
 
    effect.cs_module = wgpuDeviceCreateShaderModule(device, &descriptor);
    counters.shader_module++;
 
    std::vector<Cogs::WebGPUConstantBufferBinding> bindings = extractConstantBindingLayout(cs_source, WGPUShaderStage_Compute);
    addConstantBufferBindings(effect, bindings);
 
    WGPUCompilationInfoCallbackInfo callbackInfo = WGPU_COMPILATION_INFO_CALLBACK_INFO_INIT;
    callbackInfo.nextInChain = nullptr;
    callbackInfo.callback = compile_callback;
    callbackInfo.mode = WGPUCallbackMode_AllowProcessEvents;
    callbackInfo.userdata1 = static_cast<void*>(&cs_source);
 
    wgpuShaderModuleGetCompilationInfo(effect.cs_module, callbackInfo);
 
    return this->effects.addResource(std::move(effect));
  }
 
  EffectHandle EffectsWebGPU::load(const ProcessedContent&   vsSource,
                                   const ProcessedContent&   hsSource,
                                   const ProcessedContent&   dsSource,
                                   const ProcessedContent&   gsSource,
                                   const ProcessedContent&   fsSource,
                                   const StringView&         vsEntryPoint,
                                   const StringView&         /*hsEntryPoint*/,
                                   const StringView&         /*dsEntryPoint*/,
                                   const StringView&         /*gsEntryPoint*/,
                                   const StringView&         fsEntryPoint,
                                   const EffectDescription&  effect_desc)
  {
    EffectFlags::EEffectFlags effectFlags = effect_desc.flags;
    bool useSortedDefines = false;
    PreprocessorDefinitions unique_definitions = effect_desc.definitions;
    std::sort(unique_definitions.begin(), unique_definitions.end());
    unique_definitions.erase(std::unique(unique_definitions.begin(), unique_definitions.end()), unique_definitions.end());
    if (unique_definitions.size() != effect_desc.definitions.size()) {
      useSortedDefines = true;
      LOG_WARNING(logger, "Redefinition of precompiler defines not supported in WebGPU backend");
    }
 
    // WebGPU does only support vertex and pixel shaders
    assert(!hsSource.origin.size());
    assert(!dsSource.origin.size());
    assert(!gsSource.origin.size());
 
    WGPUDevice device = graphicsDevice->device;
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
 
    EffectWebGPU effect = {};
    effect.vs_entry = std::string(vsEntryPoint);
    effect.fs_entry = std::string(fsEntryPoint);
    effect.name = std::string(effect_desc.name);
    if ((effectFlags & Cogs::EffectFlags::EEffectFlags::LogShaderSource) == Cogs::EffectFlags::EEffectFlags::LogShaderSource) {
      LOG_INFO(logger, "Compiling WebGPU Effect: %s", effect.name.c_str());
    }
    std::string definitions_source;
    for (auto& def : useSortedDefines ? unique_definitions : effect_desc.definitions) {
      definitions_source += "const " + def.first + " = " + def.second + ";\n";
    }
    std::string vs_source = definitions_source + vsSource.content;
    {
      if ((effectFlags & Cogs::EffectFlags::EEffectFlags::LogShaderSource) == Cogs::EffectFlags::EEffectFlags::LogShaderSource) {
        LOG_INFO(logger, "Compiling WebGPU VS:\n%s", vs_source.c_str());
      }
 
      WGPUShaderModuleDescriptor descriptor = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
      descriptor.label = {effect_desc.name.data(), WGPU_STRLEN};
      WGPUShaderSourceWGSL wgsl_desc = WGPU_SHADER_SOURCE_WGSL_INIT;
      wgsl_desc.chain.sType = WGPUSType_ShaderSourceWGSL;
      wgsl_desc.code = {vs_source.c_str(), WGPU_STRLEN};
      descriptor.nextInChain = (WGPUChainedStruct*)&wgsl_desc;
 
      effect.vs_module = wgpuDeviceCreateShaderModule(device, &descriptor);
      counters.shader_module++;
 
      WGPUCompilationInfoCallbackInfo callbackInfo = WGPU_COMPILATION_INFO_CALLBACK_INFO_INIT;
      callbackInfo.nextInChain = nullptr;
      callbackInfo.callback = compile_callback;
      callbackInfo.mode = WGPUCallbackMode_AllowProcessEvents;
      callbackInfo.userdata1 = static_cast<void*>(& vs_source); // TODO Fix this for Async
      wgpuShaderModuleGetCompilationInfo(effect.vs_module, callbackInfo);
 
      // wgpuShaderModuleSetLabel(effect.vs_module, effect_desc.name.data());
      std::vector<Cogs::WebGPUConstantBufferBinding> bindings = extractConstantBindingLayout(vs_source, WGPUShaderStage_Vertex);
      addConstantBufferBindings(effect, bindings);
      {
        effect.num_attribs = extractVertexAttribLocation(vs_source, effect.semanticSlotBindings, effect.maxVertexAttribs);
      }
   }
    // TODO only create one module if they are equal?
    if (fsSource.content.size()) {
      std::string fs_source;
      fs_source = definitions_source + fsSource.content;
 
      if ((effectFlags & Cogs::EffectFlags::EEffectFlags::LogShaderSource) == Cogs::EffectFlags::EEffectFlags::LogShaderSource) {
        LOG_INFO(logger, "Compiling WebGPU FS:\n%s", fs_source.c_str());
      }
 
      WGPUShaderModuleDescriptor descriptor = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
      descriptor.label = {effect_desc.name.data(), WGPU_STRLEN};
      WGPUShaderSourceWGSL wgsl_desc = WGPU_SHADER_SOURCE_WGSL_INIT;
      wgsl_desc.chain.sType = WGPUSType_ShaderSourceWGSL;
      wgsl_desc.code = {fs_source.c_str(), WGPU_STRLEN};
      descriptor.nextInChain = (WGPUChainedStruct*)&wgsl_desc;
 
      effect.fs_module = wgpuDeviceCreateShaderModule(device, &descriptor);
      counters.shader_module++;
 
      WGPUCompilationInfoCallbackInfo callbackInfo = WGPU_COMPILATION_INFO_CALLBACK_INFO_INIT;
      callbackInfo.nextInChain = nullptr;
      callbackInfo.callback = compile_callback;
      callbackInfo.mode = WGPUCallbackMode_AllowProcessEvents;
      callbackInfo.userdata1 = static_cast<void*>(& fs_source);
      wgpuShaderModuleGetCompilationInfo(effect.fs_module, callbackInfo);
 
      // wgpuShaderModuleSetLabel(effect.fs_module, effect_desc.name.data());
      std::vector<Cogs::WebGPUConstantBufferBinding> bindings = extractConstantBindingLayout(fs_source, WGPUShaderStage_Fragment);
      addConstantBufferBindings(effect, bindings);
    }
    return this->effects.addResource(std::move(effect));
  }
  ConstantBufferBindingHandle EffectsWebGPU::getConstantBufferBinding(EffectHandle effectHandle, const StringView& name)
  {
    auto nameHash = Cogs::hash(name);
    const EffectWebGPU& effect = effects[effectHandle];
    {
      for (size_t i = 0; i < effect.num_bindings; i++) { // Does not report error if maxConstantBuffers is exceeded
        if (effect.constantBufferBindings[i].nameHash == nameHash) {
          return encodeConstantBufferBindingHandle(effect.constantBufferBindings[i]);
        }
      }
    }
    return ConstantBufferBindingHandle::NoHandle;
  }
 
  BufferBindingHandle EffectsWebGPU::getBufferBinding(EffectHandle effectHandle, const StringView& name)
  {
    ConstantBufferBindingHandle constantBuffer = getConstantBufferBinding(effectHandle, name);
    if (HandleIsValid(constantBuffer)) {
      return BufferBindingHandle(constantBuffer.handle);
    }
    return BufferBindingHandle::NoHandle;
  }
 
  bool EffectsWebGPU::addConstantBufferBindings(EffectWebGPU& effect, const std::vector<Cogs::WebGPUConstantBufferBinding>& bindings) {
    for (auto binding : bindings) {
      size_t slot;
      bool exists = false;
      for (slot = 0; slot < effect.num_bindings; slot++) { // Does not report error if maxConstantBuffers is exceeded
        auto& curr = effect.constantBufferBindings[slot];
        if (curr.nameHash == binding.nameHash) {
          if (curr.group == binding.group && curr.bg_ent.binding == binding.bg_ent.binding) {
            curr.bg_ent.visibility = curr.bg_ent.visibility | binding.bg_ent.visibility;
            exists = true;
          }
          else {
            LOG_ERROR(logger, "Inconsistent binding location");
          }
        }
      }
      if (exists) {
        continue;
      }
      if (effect.num_bindings < EffectWebGPU::maxConstantBuffers) {
        effect.constantBufferBindings[effect.num_bindings++] = binding;
      }
      else {
        LOG_ERROR(logger, "Number of bindings exceed EffectWebGPU::maxConstantBuffers=%zu", EffectWebGPU::maxConstantBuffers);
        return false;
      }
    }
    return true;
  }
      
 
  const WebGPUConstantBufferBinding* EffectsWebGPU::getConstantBufferBindings(EffectHandle effectHandle, size_t& num_bindings) {
    const EffectWebGPU& effect = effects[effectHandle];
    num_bindings = effect.num_bindings;
    return effect.constantBufferBindings;
  }
 
  TextureBindingHandle EffectsWebGPU::getTextureBinding(EffectHandle effectHandle, const StringView& name, const unsigned int /*slot*/) {
    std::string constantBufferName = std::string(name);
    ConstantBufferBindingHandle constantBuffer = getConstantBufferBinding(effectHandle, StringView(constantBufferName));
    if (HandleIsValid(constantBuffer)) {
      return TextureBindingHandle(constantBuffer.handle);
    }
    return TextureBindingHandle::NoHandle;
  }
 
  SamplerStateBindingHandle EffectsWebGPU::getSamplerStateBinding(EffectHandle effectHandle, const StringView& name, const unsigned int slot) {
    std::string constantBufferName = std::string(name);
    if (!constantBufferName.ends_with("Sampler")) {
      constantBufferName += "Sampler";
    }
 
    ConstantBufferBindingHandle constantBuffer = getConstantBufferBinding(effectHandle, StringView(constantBufferName));
    if (HandleIsValid(constantBuffer)) {
      return SamplerStateBindingHandle(constantBuffer.handle);
    }
 
    if (constantBufferName.ends_with("TextureSampler")) { // Try again with shortened name
      constantBufferName.erase(constantBufferName.length() - strlen("TextureSampler"));
      StringView shortenedName(constantBufferName);
      return getSamplerStateBinding(effectHandle, shortenedName, slot);
    }
 
    return SamplerStateBindingHandle::NoHandle;
  }
}