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_native(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_native(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_native(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> extractConstantBinding(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 = {};
        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_native(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_native(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_native(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_native(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;
  }
 
 
// Fallback to shader source parsing
  Cogs::BindingStorageTextureAccess extractStorageTextureAccess(std::string::const_iterator& type_it, std::string::const_iterator end) {
    Cogs::BindingStorageTextureAccess sta = Cogs::BindingStorageTextureAccess::WriteOnly;
    if (starts_with(type_it, end, "read_write", type_it) || starts_with(type_it, end, "readwrite", type_it)) {
      sta = Cogs::BindingStorageTextureAccess::ReadWrite;
    }
    else if (starts_with(type_it, end, "read", type_it)) {
      sta = Cogs::BindingStorageTextureAccess::ReadOnly;
    }
    else if (starts_with(type_it, end, "write", type_it)) {
      sta = Cogs::BindingStorageTextureAccess::WriteOnly;
    }
    return sta;
  }
 
 
 
  Cogs::Format extractTextureFormat(std::string::const_iterator& type_it, std::string::const_iterator end) {
    Cogs::Format tf = Cogs::Format::Unknown;
    if (starts_with(type_it, end, "rgba8unorm", type_it)) {
      tf = Cogs::Format::R8G8B8A8_UNORM;
    }
    else if (starts_with(type_it, end, "rgba8snorm", type_it)) {
      tf = Cogs::Format::R8G8B8A8_SNORM;
    }
    else if (starts_with(type_it, end, "rgba8uint", type_it)) {
      tf = Cogs::Format::R8G8B8A8_UINT;
    }
    else if (starts_with(type_it, end, "rgba8sint", type_it)) {
      tf = Cogs::Format::R8G8B8A8_SINT;
    }
    else if (starts_with(type_it, end, "rgba16uint", type_it)) {
      tf = Cogs::Format::R16G16B16A16_UINT;
    }
    else if (starts_with(type_it, end, "rgba16sint", type_it)) {
      tf = Cogs::Format::R16G16B16A16_SINT;
    }
    else if (starts_with(type_it, end, "rgba16float", type_it)) {
      tf = Cogs::Format::R16G16B16A16_FLOAT;
    }
    else if (starts_with(type_it, end, "r32uint", type_it)) {
      tf = Cogs::Format::R32_UINT;
    }
    else if (starts_with(type_it, end, "r32sint", type_it)) {
      tf = Cogs::Format::R32_SINT;
    }
    else if (starts_with(type_it, end, "r32float", type_it)) {
      tf = Cogs::Format::R32_FLOAT;
    }
    else if (starts_with(type_it, end, "rg32uint", type_it)) {
      tf = Cogs::Format::R32G32_UINT;
    }
    else if (starts_with(type_it, end, "rg32sint", type_it)) {
      tf = Cogs::Format::R32G32_SINT;
    }
    else if (starts_with(type_it, end, "rg32float", type_it)) {
      tf = Cogs::Format::R32G32_FLOAT;
    }
    else if (starts_with(type_it, end, "rgba32uint", type_it)) {
      tf = Cogs::Format::R32G32B32A32_UINT;
    }
    else if (starts_with(type_it, end, "rgba32sint", type_it)) {
      tf = Cogs::Format::R32G32B32A32_SINT;
    }
    else if (starts_with(type_it, end, "rgba32float", type_it)) {
      tf = Cogs::Format::R32G32B32A32_FLOAT;
    }
    else if (starts_with(type_it, end, "bgra8unorm", type_it)) {
      tf = Cogs::Format::B8G8R8A8;
    }
    return tf;
  }
 
  Cogs::ResourceDimensions extractViewDimention(std::string::const_iterator& type_it, std::string::const_iterator end) {
    Cogs::ResourceDimensions tvd = Cogs::ResourceDimensions::Unknown;
    if (starts_with(type_it, end, "2d_array", type_it)) {
      tvd = Cogs::ResourceDimensions::Texture2DArray;
    }
    else if (starts_with(type_it, end, "2d", type_it)) {
      tvd = Cogs::ResourceDimensions::Texture2D;
    }
    else if (starts_with(type_it, end, "cube", type_it)) {
      tvd = Cogs::ResourceDimensions::TextureCube;
    }
    else if (starts_with(type_it, end, "1d", type_it)) {
      tvd = Cogs::ResourceDimensions::Texture1D;
    }
    else if (starts_with(type_it, end, "cube_array", type_it)) {
      tvd = Cogs::ResourceDimensions::Unknown; // WGPUTextureViewDimension_CubeArray;
      LOG_ERROR_ONCE(logger, "Texture cube array not yet supported");
    }
    else if (starts_with(type_it, end, "3d", type_it)) {
      tvd = Cogs::ResourceDimensions::Texture3D;
    }
    return tvd;
  }
 
  bool extractBindingLayout(const std::string &shaderSource, Cogs::BindingVisibilityFlags usage, Cogs::BindGroupSetDescription &layoutSet) {
    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))
      {
        uint32_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;
        if (group >= Cogs::MaxBindGroups) {
          LOG_ERROR(logger, "Group number %u is out of range", group);
          return false;
        }
        if (layoutSet.numGroups <= group) layoutSet.numGroups = static_cast<uint16_t>(group + 1);
        Cogs::BindGroupDescription &bindGroup = layoutSet.groups[group];
        for (size_t i = 0; i < bindGroup.numEntries; ++i) {
          if (bindGroup.entries[i].binding != loc) continue;
          if (bindGroup.entries[i].nameHash != nameHash) {
            LOG_ERROR(logger, "Conflicting declarations for @group(%u) @binding(%u): '%s' does not match the resource already bound there.",
                      static_cast<unsigned int>(group), loc, name.c_str());
            return false;
          }
          bindGroup.entries[i].visibility |= usage;
          alreadyInserted = true;
          break;
        }
 
        if (alreadyInserted) continue;
        if (loc >= Cogs::MaxBindGroupEntries) {
          LOG_ERROR(logger, "Binding number %d is out of range", loc);
          return false;
        }
        Cogs::BindGroupEntryDescription &entry = bindGroup.entries[bindGroup.numEntries++];
        entry = {};
        entry.binding = static_cast<uint32_t>(loc);
        entry.visibility = usage;
        entry.nameHash = nameHash;
 
        if (isUniform) {
          entry.resourceType = Cogs::BindingResourceType::UniformBuffer;
        }
        else if (starts_with(type_it, type.end(), "texture_storage_", type_it)) { //  type.starts_with("texture_")
          entry.resourceType = Cogs::BindingResourceType::StorageTexture;
          entry.textureDimension = 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());
          }
          entry.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());
          entry.storageTextureAccess = 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)) {
          entry.resourceType = Cogs::BindingResourceType::Texture;
          entry.textureDimension = Cogs::ResourceDimensions::Texture2D;
          entry.textureSampleType = Cogs::BindingTextureSampleType::Float;
          entry.isDepthTexture = false;
          entry.multisampled = false;
          if (starts_with(type_it, type.end(), "depth_", type_it)) {
            entry.isDepthTexture = true;
          }
          if (starts_with(type_it, type.end(), "multisampled_", type_it)) {
            entry.multisampled = true;
          }
          entry.textureDimension = extractViewDimention(type_it, type.end());
          eat_white(type_it, type.end());
          if (entry.isDepthTexture) {
            entry.textureSampleType = Cogs::BindingTextureSampleType::Depth;
          }
          else if (starts_with(type_it, type.end(), "<f32>", type_it)) {
            if (entry.multisampled) {
              entry.textureSampleType = Cogs::BindingTextureSampleType::UnfilterableFloat;
            }
            else {
              entry.textureSampleType = Cogs::BindingTextureSampleType::Float;
            }
          }
          else if (starts_with(type_it, type.end(), "<i32>", type_it)) {
            entry.textureSampleType = Cogs::BindingTextureSampleType::Sint;
          }
          else if (starts_with(type_it, type.end(), "<u32>", type_it)) {
            entry.textureSampleType = Cogs::BindingTextureSampleType::Uint;
          }
          else {
            LOG_DEBUG(logger, "Texture type %s not yet supported", type.c_str());
          }
        }
        else if (type == "sampler") {
          entry.resourceType = Cogs::BindingResourceType::Sampler;
          entry.samplerBindingType = Cogs::BindingSamplerBindingType::Filtering;
        }
        else if (type == "sampler_comparison") {
          entry.resourceType = Cogs::BindingResourceType::Sampler;
          entry.samplerBindingType = Cogs::BindingSamplerBindingType::Comparison;
        }
        else {
          LOG_DEBUG(logger, "Unknown uniform type%s", type.c_str());
        }
      }
    }
    return true;
  }
 
  // end of fallback
 
  [[nodiscard]]
  WGPUShaderStage bindingVisibilityToShaderStage(const uint32_t visibility)
  {
    uint32_t effectiveVisibility = visibility;
    if (effectiveVisibility == Cogs::BindingVisibilityNone) {
      effectiveVisibility = Cogs::BindingVisibilityVertex | Cogs::BindingVisibilityFragment;
    }
 
    uint32_t shaderStage = 0;
    if ((effectiveVisibility & Cogs::BindingVisibilityVertex) != 0) {
      shaderStage |= WGPUShaderStage_Vertex;
    }
    if ((effectiveVisibility & Cogs::BindingVisibilityFragment) != 0) {
      shaderStage |= WGPUShaderStage_Fragment;
    }
    if ((effectiveVisibility & Cogs::BindingVisibilityCompute) != 0) {
      shaderStage |= WGPUShaderStage_Compute;
    }
 
    return static_cast<WGPUShaderStage>(shaderStage);
  }
 
  [[nodiscard]]
  WGPUTextureViewDimension ResourceDimensionsToViewDimension(const Cogs::ResourceDimensions dimension)
  {
    switch (dimension) {
    case Cogs::ResourceDimensions::Texture1D:
      return WGPUTextureViewDimension_1D;
    case Cogs::ResourceDimensions::Texture2D:
      return WGPUTextureViewDimension_2D;
    case Cogs::ResourceDimensions::Texture2DArray:
      return WGPUTextureViewDimension_2DArray;
    case Cogs::ResourceDimensions::Texture3D:
      return WGPUTextureViewDimension_3D;
    case Cogs::ResourceDimensions::TextureCube:
      return WGPUTextureViewDimension_Cube;
    default:
      return WGPUTextureViewDimension_Undefined;
    }
  }
 
  [[nodiscard]]
  WGPUStorageTextureAccess bindingStorageTextureAccessToWebGPU(Cogs::BindingStorageTextureAccess access) {
    switch (access)
    {
    case Cogs::BindingStorageTextureAccess::WriteOnly:
      return WGPUStorageTextureAccess_WriteOnly;
    case Cogs::BindingStorageTextureAccess::ReadOnly:
      return WGPUStorageTextureAccess_ReadOnly;
    case Cogs::BindingStorageTextureAccess::ReadWrite:
      return WGPUStorageTextureAccess_ReadWrite;
    default:
      return WGPUStorageTextureAccess_WriteOnly;
    }
  }
 
 
  [[nodiscard]]
  WGPUTextureSampleType bindingTextureSampleTypeToWebGPU(
    const Cogs::BindingTextureSampleType sampleType,
    const bool isDepthTexture,
    const bool multisampled)
  {
    switch (sampleType) {
    case Cogs::BindingTextureSampleType::Float:
      return multisampled ? WGPUTextureSampleType_UnfilterableFloat : WGPUTextureSampleType_Float;
    case Cogs::BindingTextureSampleType::UnfilterableFloat:
      return WGPUTextureSampleType_UnfilterableFloat;
    case Cogs::BindingTextureSampleType::Depth:
      return WGPUTextureSampleType_Depth;
    case Cogs::BindingTextureSampleType::Sint:
      return WGPUTextureSampleType_Sint;
    case Cogs::BindingTextureSampleType::Uint:
      return WGPUTextureSampleType_Uint;
    default:
      return isDepthTexture ? WGPUTextureSampleType_Depth : WGPUTextureSampleType_Float;
    }
  }
 
  [[nodiscard]]
  WGPUSamplerBindingType bindingSamplerTypeToWebGPU(
    const Cogs::BindingSamplerBindingType samplerType,
    const bool isDepthTexture,
    const size_t nameHash)
  {
    switch (samplerType) {
    case Cogs::BindingSamplerBindingType::Filtering:
      return WGPUSamplerBindingType_Filtering;
    case Cogs::BindingSamplerBindingType::NonFiltering:
      return WGPUSamplerBindingType_NonFiltering;
    case Cogs::BindingSamplerBindingType::Comparison:
      return WGPUSamplerBindingType_Comparison;
    default:
      return (isDepthTexture || nameHash == Cogs::hash("shadowSampler"))
        ? WGPUSamplerBindingType_Comparison
        : WGPUSamplerBindingType_Filtering;
    }
  }
 
  [[nodiscard]]
  WGPUTextureFormat bindingTextureFormatToWebGPU(Cogs::Format format) {
    switch (format) {
    case Cogs::Format::R8G8B8A8_UNORM:
      return WGPUTextureFormat_RGBA8Unorm;
    case Cogs::Format::R8G8B8A8_SNORM:
      return WGPUTextureFormat_RGBA8Snorm;
    case Cogs::Format::R8G8B8A8_UINT:
      return WGPUTextureFormat_RGBA8Uint;
    case Cogs::Format::R8G8B8A8_SINT:
      return WGPUTextureFormat_RGBA8Sint;
    case Cogs::Format::R16G16B16A16_UINT:
      return WGPUTextureFormat_RGBA16Uint;
    case Cogs::Format::R16G16B16A16_SINT:
      return WGPUTextureFormat_RGBA16Sint;
    case Cogs::Format::R16G16B16A16_FLOAT:
      return WGPUTextureFormat_RGBA16Float;
    case Cogs::Format::R32_UINT:
      return WGPUTextureFormat_R32Uint;
    case Cogs::Format::R32_SINT:
      return WGPUTextureFormat_R32Sint;
    case Cogs::Format::R32_FLOAT:
      return WGPUTextureFormat_R32Float;
    case Cogs::Format::R32G32_UINT:
      return WGPUTextureFormat_RG32Uint;
    case Cogs::Format::R32G32_SINT:
      return WGPUTextureFormat_RG32Sint;
    case Cogs::Format::R32G32_FLOAT:
      return WGPUTextureFormat_RG32Float;
    case Cogs::Format::R32G32B32A32_UINT:
      return WGPUTextureFormat_RGBA32Uint;
    case Cogs::Format::R32G32B32A32_SINT:
      return WGPUTextureFormat_RGBA32Sint;
    case Cogs::Format::R32G32B32A32_FLOAT:
      return WGPUTextureFormat_RGBA32Float;
    case Cogs::Format::B8G8R8A8:
      return WGPUTextureFormat_BGRA8Unorm;
    default:
      return WGPUTextureFormat_Undefined;
    }
  }
 
 
  [[nodiscard]]
  bool getWebGPUConstantBufferBindingsFromMetadata(
    const Cogs::BindGroupSetDescription* layoutSet,
    std::vector<Cogs::WebGPUConstantBufferBinding>& outBindings)
  {
//    const Cogs::BindGroupSetDescription* layoutSet = &effectDescription.bindGroupLayoutDesc;
    outBindings.clear();
 
    for (uint16_t groupIdx = 0; groupIdx < layoutSet->numGroups; groupIdx++) {
      const Cogs::BindGroupDescription& group = layoutSet->groups[groupIdx];
      if (group.numEntries == 0) continue;
      for (uint16_t entryIdx = 0; entryIdx < group.numEntries; entryIdx++) {
        const Cogs::BindGroupEntryDescription& entry = group.entries[entryIdx];
        WGPUBindGroupLayoutEntry bg_ent = WGPU_BIND_GROUP_LAYOUT_ENTRY_INIT;
        bg_ent.binding = entry.binding;
        bg_ent.visibility = bindingVisibilityToShaderStage(entry.visibility);
 
        switch (entry.resourceType) {
        case Cogs::BindingResourceType::UniformBuffer:
          bg_ent.buffer.type = WGPUBufferBindingType_Uniform;
          break;
        case Cogs::BindingResourceType::StorageBuffer:
          bg_ent.buffer.type = WGPUBufferBindingType_Storage;
          break;
        case Cogs::BindingResourceType::Texture:
          bg_ent.texture.viewDimension = ResourceDimensionsToViewDimension(entry.textureDimension);
          bg_ent.texture.multisampled = entry.multisampled ? 1 : 0;
          bg_ent.texture.sampleType = bindingTextureSampleTypeToWebGPU(entry.textureSampleType,
            entry.isDepthTexture,
            entry.multisampled);
          break;
        case Cogs::BindingResourceType::Sampler:
          bg_ent.sampler.type = bindingSamplerTypeToWebGPU(entry.samplerBindingType,
            entry.isDepthTexture,
            entry.nameHash);
          break;
        case Cogs::BindingResourceType::StorageTexture:
          bg_ent.storageTexture.viewDimension = ResourceDimensionsToViewDimension(entry.textureDimension);
          bg_ent.storageTexture.access = bindingStorageTextureAccessToWebGPU(entry.storageTextureAccess);
          bg_ent.storageTexture.format = bindingTextureFormatToWebGPU(entry.format);
          break;
        default:
          LOG_ERROR(logger,
            "Unsupported bind-group resource type %d for entry '%d''.",
            int(entry.resourceType),
            entry.binding);
          return false;
        }
 
        Cogs::WebGPUConstantBufferBinding binding{};
        binding.group = groupIdx;
        binding.nameHash = entry.nameHash;
        //        binding.nameHash = entry.nameHash ? entry.nameHash : Cogs::hash(entry.name);
        binding.bg_ent = bg_ent;
        outBindings.push_back(std::move(binding));
      }
    }
 
    return true;
  }
 
 
 
 
  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(uint16_t groupIdx, uint16_t binding) {
    size_t i = (static_cast<size_t>(groupIdx) << 16) + (binding + 1);
    return (Cogs::ConstantBufferBindingHandle)i;
  }
 
  void decodeConstantBufferBindingHandle(Cogs::ConstantBufferBindingHandle handle, size_t& group, uint32_t& binding)
  {
    int64_t i = handle.handle;
    group = static_cast<size_t>(i >> 16);
    binding = static_cast<uint32_t>((i & 0xFFFF) - 1);
  }
 
  Cogs::BindingResourceType bindingResourceTypeFromWebGPU(const WGPUBindGroupLayoutEntry& entry)
  {
    if (entry.buffer.type != WGPUBufferBindingType_Undefined) {
      return (entry.buffer.type == WGPUBufferBindingType_Uniform) ? Cogs::BindingResourceType::UniformBuffer : Cogs::BindingResourceType::StorageBuffer;
    }
    if (entry.texture.sampleType != WGPUTextureSampleType_Undefined) {
      return Cogs::BindingResourceType::Texture;
    }
    if (entry.sampler.type != WGPUSamplerBindingType_Undefined) {
      return Cogs::BindingResourceType::Sampler;
    }
    if (entry.storageTexture.access != WGPUStorageTextureAccess_Undefined) {
      return Cogs::BindingResourceType::StorageTexture;
    }
    return Cogs::BindingResourceType::UniformBuffer;
  }
 
  Cogs::ResourceDimensions textureDimensionFromWebGPU(WGPUTextureViewDimension dim)
  {
    switch (dim) {
    case WGPUTextureViewDimension_1D: return Cogs::ResourceDimensions::Texture1D;
    case WGPUTextureViewDimension_2D: return Cogs::ResourceDimensions::Texture2D;
    case WGPUTextureViewDimension_2DArray: return Cogs::ResourceDimensions::Texture2DArray;
    case WGPUTextureViewDimension_3D: return Cogs::ResourceDimensions::Texture3D;
    case WGPUTextureViewDimension_Cube:
    case WGPUTextureViewDimension_CubeArray:
      return Cogs::ResourceDimensions::TextureCube;
    default:
      return Cogs::ResourceDimensions::Unknown;
    }
  }
 
  Cogs::BindingTextureSampleType textureSampleTypeFromWebGPU(WGPUTextureSampleType sampleType)
  {
    switch (sampleType) {
    case WGPUTextureSampleType_Float: return Cogs::BindingTextureSampleType::Float;
    case WGPUTextureSampleType_UnfilterableFloat: return Cogs::BindingTextureSampleType::UnfilterableFloat;
    case WGPUTextureSampleType_Depth: return Cogs::BindingTextureSampleType::Depth;
    case WGPUTextureSampleType_Sint: return Cogs::BindingTextureSampleType::Sint;
    case WGPUTextureSampleType_Uint: return Cogs::BindingTextureSampleType::Uint;
    default:
      return Cogs::BindingTextureSampleType::Unknown;
    }
  }
 
  Cogs::BindingSamplerBindingType samplerTypeFromWebGPU(WGPUSamplerBindingType samplerType)
  {
    switch (samplerType) {
    case WGPUSamplerBindingType_Filtering: return Cogs::BindingSamplerBindingType::Filtering;
    case WGPUSamplerBindingType_NonFiltering: return Cogs::BindingSamplerBindingType::NonFiltering;
    case WGPUSamplerBindingType_Comparison: return Cogs::BindingSamplerBindingType::Comparison;
    default:
      return Cogs::BindingSamplerBindingType::Unknown;
    }
  }
 
  bool bindGroupEntryEquals(const WGPUBindGroupEntry& a, const WGPUBindGroupEntry& b)
  {
    return a.binding == b.binding &&
      a.buffer == b.buffer &&
      a.offset == b.offset &&
      a.size == b.size &&
      a.sampler == b.sampler &&
      a.textureView == b.textureView;
  }
 
  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()
  {
    std::vector<EffectHandle> handles;
    for (auto& resource : effects) {
      handles.push_back(effects.getHandle(resource));
    }
    for (auto& handle : handles) {
      releaseEffect(handle);
    }
  }
 
  void EffectsWebGPU::releaseEffect(EffectHandle handle)
  {
    if (!HandleIsValid(handle)) return;
 
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    EffectWebGPU &effect = this->effects[handle];
    if(effect.vs_module){
      wgpuShaderModuleRelease(effect.vs_module);
      counters.shader_module--;
    }
    if(effect.fs_module){
      wgpuShaderModuleRelease(effect.fs_module);
      counters.shader_module--;
    }
    if(effect.cs_module){
      wgpuShaderModuleRelease(effect.cs_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++;
 
 
    // effect.bindGroupSetDescription = effect_desc.bindGroupLayoutDesc; // should open up for something here
    if (!extractBindingLayout(cs_source, Cogs::BindingVisibilityFlags::BindingVisibilityCompute, effect.bindGroupSetDescription)) {
      return Cogs::EffectHandle::NoHandle;
    }
 
 
    std::vector<Cogs::WebGPUConstantBufferBinding> bindings = extractConstantBinding(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);
 
    effect.updateBindGroupDescHashes();
    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";
    }
 
    bool hasBindingMetadata = effect_desc.bindGroupLayoutDesc.numGroups > 0;
    
    if (effect_desc.bindGroupLayoutDesc.numGroups > 0) {
      effect.bindGroupSetDescription = effect_desc.bindGroupLayoutDesc;
      hasBindingMetadata = true;
    } else {
      LOG_INFO_ONCE(logger, "Effect %s missing binding metadata parsing shader source as fallback", effect.name.c_str());
    }
 
    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());
      {
        effect.num_attribs = extractVertexAttribLocation(vs_source, effect.semanticSlotBindings, effect.maxVertexAttribs);
      }
 
      if (!hasBindingMetadata) {
        if (!extractBindingLayout(vs_source, Cogs::BindingVisibilityFlags::BindingVisibilityVertex, effect.bindGroupSetDescription)) {
          return Cogs::EffectHandle::NoHandle;
        }
      }
    }
    // 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);
 
      if (!hasBindingMetadata) {
        if (!extractBindingLayout(fs_source, Cogs::BindingVisibilityFlags::BindingVisibilityFragment, effect.bindGroupSetDescription)) {
          return Cogs::EffectHandle::NoHandle;
        }
      }
      // wgpuShaderModuleSetLabel(effect.fs_module, effect_desc.name.data());
    }
 
    std::vector<Cogs::WebGPUConstantBufferBinding> metadataBindings;
    if (!getWebGPUConstantBufferBindingsFromMetadata(&effect.bindGroupSetDescription, metadataBindings)) {
      return Cogs::EffectHandle::NoHandle;
    }
 
    if (!addConstantBufferBindings(effect, metadataBindings)) {
      return Cogs::EffectHandle::NoHandle;
    }
 
 
 
    effect.updateBindGroupDescHashes();
    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 (uint16_t g = 0; g < effect.bindGroupSetDescription.numGroups; g++) {
      const BindGroupDescription& group = effect.bindGroupSetDescription.groups[g];
      for (uint16_t i = 0; i < group.numEntries; i++) {
        if (group.entries[i].nameHash == nameHash) {
          return encodeConstantBufferBindingHandle(g, i);
        }
      }
    }
    return ConstantBufferBindingHandle::NoHandle;
  }
 
  const BindGroupDescription& EffectsWebGPU::getBindGroupDescription(EffectHandle effectHandle, uint32_t groupIndex) {
    if (!HandleIsValid(effectHandle) || !effects.hasResource(effectHandle)) {
      return IEffects::getBindGroupDescription(effectHandle, groupIndex); //empty description
    }
    const EffectWebGPU& effect = effects[effectHandle];
    if (groupIndex >= effect.bindGroupSetDescription.numGroups) {
      return IEffects::getBindGroupDescription(effectHandle, groupIndex); //empty description      
    }
    return effect.bindGroupSetDescription.groups[groupIndex];
  }
 
  static const size_t emptyBindGroupDescHash = BindGroupDescription().hash();
 
  size_t EffectsWebGPU::getBindGroupDescHash(EffectHandle effectHandle, uint32_t groupIndex) {
    if (!HandleIsValid(effectHandle) || !effects.hasResource(effectHandle)) {
      return emptyBindGroupDescHash;
    }
    const EffectWebGPU& effect = effects[effectHandle];
    if (groupIndex >= effect.bindGroupSetDescription.numGroups) {
      return emptyBindGroupDescHash;
    }
    return effect.bindGroupDescHash[groupIndex];
  }
 
  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;
  }
      
 
  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;
  }
 
  /*
  bool EffectsWebGPU::getBindGroupLayout(EffectHandle effectHandle, uint32_t groupIndex, BindGroupLayout& layoutOutput)
  {
    if (!HandleIsValid(effectHandle) || !effects.hasResource(effectHandle)) {
      return false;
    }
 
    const EffectWebGPU& effect = effects[effectHandle];
    layoutOutput = {};
 
    if (groupIndex < effect.bindGrouplayouts.groups.size()) {
      layoutOutput = effect.bindGrouplayouts.groups[0];
      return true;
    }
 
    for (size_t i = 0; i < effect.num_bindings; ++i) {
      const auto& binding = effect.constantBufferBindings[i];
      if (binding.group != groupIndex) {
        continue;
      }
 
      BindGroupLayoutEntry entry = {};
      entry.binding = binding.bg_ent.binding;
      entry.name = binding.name;
      entry.nameHash = binding.nameHash;
      entry.resourceType = bindingResourceTypeFromWebGPU(binding.bg_ent);
      entry.visibility = static_cast<uint32_t>(binding.bg_ent.visibility);
      entry.arrayCount = 1;
      entry.textureDimension = textureDimensionFromWebGPU(binding.bg_ent.texture.viewDimension);
      entry.textureSampleType = textureSampleTypeFromWebGPU(binding.bg_ent.texture.sampleType);
      entry.samplerBindingType = samplerTypeFromWebGPU(binding.bg_ent.sampler.type);
      entry.isDepthTexture = (binding.bg_ent.texture.sampleType == WGPUTextureSampleType_Depth);
      entry.multisampled = binding.bg_ent.texture.multisampled;
      entry.hasDynamicOffset = binding.bg_ent.buffer.hasDynamicOffset;
 
      layoutOutput.entries.push_back(std::move(entry));
    }
 
    return !layoutOutput.entries.empty();
  }
  */
 
  uint32_t EffectsWebGPU::getNumBindGroups(EffectHandle effectHandle) {
    if (!HandleIsValid(effectHandle) || !effects.hasResource(effectHandle)) {
      return 0;
    }
    const EffectWebGPU& effect = effects[effectHandle];
    return effect.bindGroupSetDescription.numGroups;
  }
}