TexturesWebGPU.cpp

#include "TexturesWebGPU.h"
 
#include "FormatsWebGPU.h"
#include "GraphicsDeviceWebGPU.h"
#include "Foundation/Logging/Logger.h"
 
#include "Foundation/StringView.h"
 
#include <glm/gtc/color_space.hpp>
#include <glm/detail/func_packing.inl>
 
namespace{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexturesWebGPU");
  WGPUCompareFunction wgpu(Cogs::SamplerState::ComparisonFunction cmp)
  {
    switch(cmp){
    case Cogs::SamplerState::ComparisonFunction::Never:
      return WGPUCompareFunction_Never;
    case Cogs::SamplerState::ComparisonFunction::Less:
      return WGPUCompareFunction_Less;
    case Cogs::SamplerState::ComparisonFunction::Equal:
      return WGPUCompareFunction_Equal;
    case Cogs::SamplerState::ComparisonFunction::LessEqual:
      return WGPUCompareFunction_LessEqual;
    case Cogs::SamplerState::ComparisonFunction::Greater:
      return WGPUCompareFunction_Greater;
    case Cogs::SamplerState::ComparisonFunction::NotEqual:
      return WGPUCompareFunction_NotEqual;
    case Cogs::SamplerState::ComparisonFunction::GreaterEqual:
      return WGPUCompareFunction_GreaterEqual;
    case Cogs::SamplerState::ComparisonFunction::Always:
      return WGPUCompareFunction_Always;
    case Cogs::SamplerState::ComparisonFunction::ComparisonFunction_Size:
      break;
    }
    assert(false);
    return  WGPUCompareFunction_Undefined;
  }
 
  WGPUAddressMode wgpu(Cogs::SamplerState::AddressMode address_mode)
  {
    switch(address_mode){
    case Cogs::SamplerState::AddressMode::Clamp:
      return WGPUAddressMode_ClampToEdge;
    case Cogs::SamplerState::AddressMode::Wrap:
      return WGPUAddressMode_Repeat;
    case Cogs::SamplerState::AddressMode::Mirror:
      return WGPUAddressMode_MirrorRepeat;
    case Cogs::SamplerState::AddressMode::Border:
      LOG_WARNING_ONCE(logger, "WebGPU backend does not support SamplerState::AddressMode::Border.");
      return WGPUAddressMode_ClampToEdge;
    case Cogs::SamplerState::AddressMode::AddressMode_Size:
      break;
    }
    assert(false);
    return WGPUAddressMode_Repeat;
  }
}
 
namespace Cogs{
 
  void TexturesWebGPU::initialize(class GraphicsDeviceWebGPU *device)
  {
    graphicsDevice = device;
  }
 
  void TexturesWebGPU::annotate(TextureHandle handle, const StringView& name)
  {
    TextureWebGPU &texture = textures[handle];
    wgpuTextureSetLabel(texture.texture, {name.data(), WGPU_STRLEN});
  }
 
  static void writeMipLevelToGPU(GraphicsDeviceWebGPU *graphicsDevice, WGPUTexture *destinationTexture, void *data, uint32_t cubeFace, uint32_t arrayLayer, uint32_t mipLevel, Cogs::TextureExtent textureExtent, size_t levelSize, uint32_t bytesPerPixel)
  {
    WGPUTexelCopyBufferLayout layout = {};
    layout.offset = 0;
    layout.bytesPerRow = bytesPerPixel * textureExtent.width;
    layout.rowsPerImage = textureExtent.height;
 
    WGPUTexelCopyTextureInfo destination = {};
    destination.texture = *destinationTexture;
    destination.aspect = WGPUTextureAspect_All;
    destination.origin = { 0, 0, static_cast<uint32_t>(arrayLayer + cubeFace) };
    destination.mipLevel = static_cast<uint32_t>(mipLevel);
    WGPUExtent3D sizeExtent = { textureExtent.width, textureExtent.height, textureExtent.depth };
    wgpuQueueWriteTexture(graphicsDevice->queue, &destination, data, levelSize, &layout, &sizeExtent);
  }
 
  template <typename T>
  static void convertMiplevelDataToFloatData(float *out, T *data, size_t nPixels, uint32_t channels, bool isSigned, bool isFloat, bool isHalfFloat, bool isSRGB, bool hasAlpha)
  {
    float valRange = std::powf(2, 8 * sizeof(T)) - 1.0f;
 
    memcpy(out, data, static_cast<size_t>(isFloat) * nPixels * channels * sizeof(float));
 
    for(size_t pixel = 0; pixel < nPixels * static_cast<size_t>(!isFloat); pixel++) {
      for(size_t channel = 0; channel < channels; channel++) {
        T channelData = data[(pixel * channels) + channel];
        size_t isSignBitSet = static_cast<size_t>(isSigned) & (static_cast<size_t>(channelData) >> ((sizeof(T) * 8) - 1));
 
 
        T channelDataShifted = channelData + static_cast<T>((static_cast<size_t>(!isHalfFloat) * isSignBitSet * (static_cast<size_t>(valRange) >> 1)));
 
        glm::vec2 halfFloatToFloatVec = glm::unpackHalf2x16(static_cast<uint32_t>(channelDataShifted));
        float halfFloatToFloat = halfFloatToFloatVec.x;
 
        float channelDataAsFloat = (static_cast<size_t>(!isHalfFloat) * static_cast<float>(channelDataShifted) / valRange) + (static_cast<float>(static_cast<size_t>(isHalfFloat)) * halfFloatToFloat);
        channelDataAsFloat -= 1.0f * isSignBitSet * static_cast<size_t>(!isHalfFloat);
 
        size_t isNotAlphaChannel = static_cast<size_t>(!hasAlpha) + (static_cast<size_t>(hasAlpha) * static_cast<size_t>((channel < (channels-1))));
        size_t isAlphaChannel = static_cast<size_t>(hasAlpha) * static_cast<size_t>((channel == (channels-1)));
 
        glm::vec3 channelDataVecGamma = glm::convertSRGBToLinear(glm::vec3(channelDataAsFloat, 0.0f, 0.0f));
        float channelDataGamma = channelDataVecGamma.r;
 
        float dataSRGBToLinear = static_cast<size_t>(isSRGB) * ((isNotAlphaChannel * channelDataGamma) + (isAlphaChannel * channelDataAsFloat));
 
        channelDataAsFloat = (static_cast<size_t>(!isSRGB) * channelDataAsFloat) + (static_cast<size_t>(isSRGB) * dataSRGBToLinear);
 
        out[(pixel * channels) + channel] = channelDataAsFloat;
      }
    }
  }
 
  template <typename T>
  static void nextMiplevelFromFloatData(T *nativeTypeOut, float *data, Cogs::TextureExtent textureExtent, uint32_t channels, bool isSigned, bool isFloat, bool isHalfFloat, bool isSRGB, bool hasAlpha)
  {
    float valRange = std::powf(2, 8 * sizeof(T)) - 1.0f;
 
    for (size_t y = 0; y < textureExtent.height; y++)
    {
      for (size_t x = 0; x < textureExtent.width; x++)
      {
        float *writeFloat = &data[channels * (y * textureExtent.width + x)];
        T *write = &nativeTypeOut[channels * (y * textureExtent.width + x)];
 
        float *s0 = &data[channels * ((2 * y + 0) * (2 * textureExtent.width) + (2 * x + 0))];
        float *s1 = &data[channels * ((2 * y + 0) * (2 * textureExtent.width) + (2 * x + 1))];
        float *s2 = &data[channels * ((2 * y + 1) * (2 * textureExtent.width) + (2 * x + 0))];
        float *s3 = &data[channels * ((2 * y + 1) * (2 * textureExtent.width) + (2 * x + 1))];
 
        for (size_t channel = 0; channel < channels; channel++) {
          float channelDataFloat = (s0[channel] + s1[channel] + s2[channel] + s3[channel]) / 4.0f;
 
          writeFloat[channel] = channelDataFloat;
 
          size_t isSignBitSet = static_cast<size_t>(isSigned) & (static_cast<size_t>(channelDataFloat) >> ((sizeof(T) * 8) - 1));
 
          float channelDataFloatShifted = channelDataFloat + 1.0f * static_cast<float>(static_cast<size_t>(!isHalfFloat)) * static_cast<float>(isSignBitSet) * static_cast<float>(static_cast<size_t>(!isFloat));
 
          size_t isNotAlphaChannel = static_cast<size_t>(!hasAlpha) + (static_cast<size_t>(hasAlpha) * static_cast<size_t>((channel < (channels-1))));
          size_t isAlphaChannel = static_cast<size_t>(hasAlpha) * static_cast<size_t>((channel == (channels-1)));
 
          glm::vec3 channelDataVecGamma = glm::convertLinearToSRGB(glm::vec3(channelDataFloatShifted, 0.0f, 0.0f));
          float channelDataGamma = channelDataVecGamma.r;
 
          float channelDataLinearToSRGB = static_cast<size_t>(isSRGB) * ((isNotAlphaChannel * channelDataGamma) + (isAlphaChannel * channelDataFloatShifted));
 
          channelDataFloatShifted = (static_cast<size_t>(!isSRGB) * channelDataFloatShifted) + (static_cast<size_t>(isSRGB) * channelDataLinearToSRGB);
 
          uint16_t floatToHalfFloat = static_cast<uint16_t>(glm::packHalf2x16(glm::vec2(channelDataFloat, 0.0f)));
 
          T channelData = static_cast<T>((static_cast<size_t>(!isFloat) * static_cast<size_t>(!isHalfFloat) * channelDataFloatShifted * valRange) + (static_cast<size_t>(isFloat) * channelDataFloat) + (static_cast<size_t>(isHalfFloat) * floatToHalfFloat));
 
          write[channel] = channelData;
        }
      }
    }
  }
 
  template <typename T>
  static void generateMipmapsInternal(GraphicsDeviceWebGPU *graphicsDevice, WGPUTexture *destinationTexture, const TextureData *data, uint32_t faces, uint32_t layers, uint32_t levels, uint32_t bytesPerChannel, uint32_t channels, bool isSigned, bool isFloat, bool isHalfFloat, bool isSRGB, bool hasAlpha)
  {
    uint32_t bytesPerPixel = bytesPerChannel * channels;
    size_t nPixels = data->getLevelSize(0) / bytesPerPixel;
 
    size_t levelSize = data->getLevelSize(0);
 
    std::vector<T> currLevelData(levelSize);
    std::vector<T> prevLevelData(nPixels * channels);
    std::vector<float> prevLevelDataFloat(nPixels * channels);
 
    Cogs::TextureExtent textureExtent = {};
 
    for (uint32_t f = 0; f < faces; ++f) { // Faces
      for (uint32_t a = 0; a < layers; ++a) { // Array layers
        textureExtent = data->getExtent(0);
 
        T* tmpLevelData = reinterpret_cast<T*>(const_cast<void*>(data->getData(a, f, 0)));
        memcpy(prevLevelData.data(), tmpLevelData, levelSize);
 
        writeMipLevelToGPU(graphicsDevice, destinationTexture, prevLevelData.data(), f, a, 0, textureExtent, levelSize, bytesPerPixel);
 
        convertMiplevelDataToFloatData<T>(prevLevelDataFloat.data(), prevLevelData.data(), nPixels, channels, isSigned, isFloat, isHalfFloat, isSRGB, hasAlpha);
 
        for (uint32_t m = 1; m < levels; ++m) { // Miplevels
          textureExtent = data->getExtent(m);
          size_t currentLevelSize = data->getLevelSize(m);
 
          nextMiplevelFromFloatData(currLevelData.data(), prevLevelDataFloat.data(), textureExtent, channels, isSigned, isFloat, isHalfFloat, isSRGB, hasAlpha);
 
          writeMipLevelToGPU(graphicsDevice, destinationTexture, currLevelData.data(), f, a, m, textureExtent, currentLevelSize, bytesPerPixel);
        }
      }
    }
  }
 
  TextureHandle TexturesWebGPU::loadTexture(const TextureDescription &td, const TextureData *data)
  {
    const bool generateMips = (td.flags & TextureFlags::GenerateMipMaps) != 0;
    WGPUDevice device = graphicsDevice->device;
 
    TextureWebGPU texture = {};
 
    WGPUTextureFormat format = TextureFormatsWebGPU[(size_t)td.format];
    WGPUTextureFormat view_formats[] = {format};
 
    uint32_t mipLevelCount = td.levels;
 
    // Create texture
    WGPUTextureDescriptor desc = {};
    desc.usage = WGPUTextureUsage_CopyDst | WGPUTextureUsage_TextureBinding;
    desc.usage |= WGPUTextureUsage_CopySrc; // TODO add to td.flags???
    if((td.flags&TextureFlags::RenderTarget) != 0 ||
       (td.flags&TextureFlags::DepthBuffer) != 0){
      desc.usage = WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding;
    }
    if((td.flags&TextureFlags::ReadWriteTexture) != 0){
      desc.usage |= WGPUTextureUsage_StorageBinding;
    }
    if(td.target == ResourceDimensions::Texture1D ||
       td.target == ResourceDimensions::Texture1DArray){
      desc.dimension = WGPUTextureDimension_1D;
    }
    else if(td.target == ResourceDimensions::Texture3D ||
            td.target == ResourceDimensions::Texture3DArray){
      desc.dimension = WGPUTextureDimension_3D;
    }
    else{
      desc.dimension = WGPUTextureDimension_2D;
    }
 
    const Cogs::FormatInfo *textureFormat = Cogs::getFormatInfo(td.format);
    bool compressedFormat = 
      ((textureFormat->blockExtent.width != 1) ||
      (textureFormat->blockExtent.height != 1) ||
      (textureFormat->blockExtent.depth != 1));
 
    if(generateMips) {
      if(compressedFormat) {
        LOG_WARNING_ONCE(logger, "Generating mips for compressed textures is not supported.");
      } else {
        size_t max = glm::max(td.width, td.height);
        if (max != 0) {
          mipLevelCount = 1;
          while (max >>= 1) {
            ++mipLevelCount;
          }
        }
      }
    }
 
    desc.size = {td.width, td.height, td.depth*td.faces*td.layers };
    desc.format = format;
    desc.mipLevelCount = mipLevelCount;
    desc.sampleCount = td.samples;
    desc.viewFormatCount = sizeof(view_formats)/sizeof(view_formats[0]);
    desc.viewFormats = view_formats;
 
#ifndef EMSCRIPTEN
    wgpuDeviceValidateTextureDescriptor(device, &desc);
#endif
    texture.texture = wgpuDeviceCreateTexture(device, &desc);
 
    // Create default texture view
    texture.view_format = desc.format;
    texture.format = td.format;
    if(td.target == ResourceDimensions::Texture1D ||
       td.target == ResourceDimensions::Texture1DArray){
      texture.view_dimension = WGPUTextureViewDimension_1D;
    }
    else if(td.target == ResourceDimensions::Texture2D ||
            td.target == ResourceDimensions::Texture2DMS){
      texture.view_dimension = WGPUTextureViewDimension_2D;
    }
    else if(td.target == ResourceDimensions::Texture2DArray ||
            td.target == ResourceDimensions::Texture2DMSArray){
      texture.view_dimension = WGPUTextureViewDimension_2DArray;
    }
    else if(td.target == ResourceDimensions::Texture3D ||
            td.target == ResourceDimensions::Texture3DArray){
      texture.view_dimension = WGPUTextureViewDimension_3D;
    }
    else if(td.target == ResourceDimensions::TextureCube){
      texture.view_dimension = WGPUTextureViewDimension_Cube;
    }
    else if(td.target == ResourceDimensions::TextureCubeArray){
      texture.view_dimension = WGPUTextureViewDimension_CubeArray;
    }
    else{
      assert(false);
    }
 
    WGPUTextureViewDescriptor view_desc = {};
    view_desc.label = {"DefaultTextureView", WGPU_STRLEN};
    view_desc.format = format;
    view_desc.dimension = texture.view_dimension;
    view_desc.baseMipLevel = 0;
    view_desc.mipLevelCount = mipLevelCount;
    view_desc.baseArrayLayer = 0;
    view_desc.arrayLayerCount = td.faces*td.layers;
    view_desc.aspect = WGPUTextureAspect_All;
    texture.texture_view = wgpuTextureCreateView(texture.texture, &view_desc);
 
    texture.width = td.width;
    texture.height = td.height;
    texture.samples = td.samples;
 
    // Upload Data
    if(data){
      uint32_t faces = std::min(td.faces, static_cast<uint32_t>(data->faces));
      uint32_t layers = std::min(td.layers, static_cast<uint32_t>(data->layers));
      uint32_t levels = mipLevelCount;
 
      if(generateMips && !compressedFormat) {
        uint32_t bytesPerChannel = textureFormat->blockSize / textureFormat->elements;
        Cogs::DataFormat formatType = parseDataFormat(textureFormat->name);
 
        switch (formatType) {
          case(Cogs::DataFormat::R8_UNORM):
          case(Cogs::DataFormat::R8G8_UNORM):
          case(Cogs::DataFormat::R8G8B8_UNORM):
          case(Cogs::DataFormat::R8G8B8A8_UNORM): 
            {
              generateMipmapsInternal<uint8_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R8_SNORM):
          case(Cogs::DataFormat::R8G8_SNORM):
          case(Cogs::DataFormat::R8G8B8_SNORM):
          case(Cogs::DataFormat::R8G8B8A8_SNORM): 
            {
              generateMipmapsInternal<uint8_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  true, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R16_UNORM):
          case(Cogs::DataFormat::R16G16_UNORM):
          case(Cogs::DataFormat::R16G16B16_UNORM):
          case(Cogs::DataFormat::R16G16B16A16_UNORM): 
            {
              generateMipmapsInternal<uint16_t>(
                  graphicsDevice,
                  &texture.texture, 
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R16_SNORM):
          case(Cogs::DataFormat::R16G16_SNORM):
          case(Cogs::DataFormat::R16G16B16_SNORM):
          case(Cogs::DataFormat::R16G16B16A16_SNORM): 
            {
              generateMipmapsInternal<uint16_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  true, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R16_FLOAT):
          case(Cogs::DataFormat::R16G16_FLOAT):
          case(Cogs::DataFormat::R16G16B16_FLOAT):
          case(Cogs::DataFormat::R16G16B16A16_FLOAT): 
            {
              generateMipmapsInternal<uint16_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  false, // isFloat
                  true, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R32_FLOAT):
          case(Cogs::DataFormat::R32G32_FLOAT):
          case(Cogs::DataFormat::R32G32B32_FLOAT):
          case(Cogs::DataFormat::R32G32B32A32_FLOAT): 
            {
              generateMipmapsInternal<float>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  true, // isFloat
                  false, // isHalfFloat
                  false, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R8G8B8_UNORM_SRGB):
            {
              generateMipmapsInternal<uint8_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  true, // isSRGB
                  false); // hasAlpha
              break;
            }
          case(Cogs::DataFormat::R8G8B8A8_UNORM_SRGB):
            {
              generateMipmapsInternal<uint8_t>(
                  graphicsDevice,
                  &texture.texture,
                  data,
                  faces,
                  layers,
                  levels,
                  bytesPerChannel,
                  textureFormat->elements, // number of channels
                  false, // isSigned
                  false, // isFloat
                  false, // isHalfFloat
                  true, // isSRGB
                  true); // hasAlpha
              break;
            }
          default: {
            break;
          }
        }
      } else {
        for (size_t f = 0; f < faces; ++f) { // Faces
          for (size_t a = 0; a < layers; ++a) { // Array layer
            for (size_t m = 0; m < mipLevelCount; ++m) { // Array layer
              Cogs::TextureExtent extent = data->getExtent(m);
              const void* ptr = data->getData(a, f, m);
              const size_t ptr_size = data->getLevelSize(m);
 
              if ((extent.width % data->blockExtent.width) != 0) {
                extent.width = (extent.width / data->blockExtent.width + 1) * data->blockExtent.width;
              }
              if ((extent.height % data->blockExtent.height) != 0) {
                extent.height = (extent.height / data->blockExtent.height + 1) * data->blockExtent.height;
              }
 
              WGPUTexelCopyTextureInfo dst = {};
              dst.texture = texture.texture;
              dst.mipLevel = (uint32_t)m;
              dst.origin = { 0, 0, (uint32_t)(a + f) };
              dst.aspect = WGPUTextureAspect_All;
 
              WGPUTexelCopyBufferLayout layout = {};
              layout.offset = 0;
              layout.bytesPerRow = (uint32_t)data->getPitch(m);
              layout.rowsPerImage = extent.height;
              WGPUExtent3D size = { extent.width, extent.height, extent.depth };
              wgpuQueueWriteTexture(graphicsDevice->queue, &dst, ptr, ptr_size, &layout, &size);
            }
          }
        }
      }
    }
 
    return textures.addResource(std::move(texture));
  }
 
 
  void TexturesWebGPU::releaseTexture(TextureHandle handle)
  {
    if(!HandleIsValid(handle)) return;
 
    TextureWebGPU &texture = textures[handle];
    wgpuTextureDestroy(texture.texture);
    wgpuTextureRelease(texture.texture);
 
    textures.removeResource(handle);
  }
 
  TextureViewHandle TexturesWebGPU::createTextureView(TextureViewDescription &view)
  {
    const TextureWebGPU &texture = textures[view.texture];
 
    TextureViewWebGPU texture_view = {};
 
    WGPUTextureViewDescriptor desc = {};
    desc.format = texture.view_format;
    desc.dimension = texture.view_dimension;
    if(view.numLayers == 1){
      switch(desc.dimension){
      case WGPUTextureViewDimension_2DArray:
        desc.dimension = WGPUTextureViewDimension_2D;
        break;
      case WGPUTextureViewDimension_CubeArray:
        desc.dimension = WGPUTextureViewDimension_Cube;
        break;
      default:
        break;
      }
    }
    desc.baseMipLevel = view.levelIndex;
    desc.mipLevelCount = view.numLevels;
    desc.baseArrayLayer = view.layerIndex;
    desc.arrayLayerCount = view.numLayers;
    desc.aspect = WGPUTextureAspect_All;
    texture_view.texture_view = wgpuTextureCreateView(texture.texture, &desc);
 
    return textureViews.addResource(std::move(texture_view));
  }
 
  void TexturesWebGPU::releaseTextureView(const TextureViewHandle &handle)
  {
    if(!HandleIsValid(handle)) return;
 
    TextureViewWebGPU &texture_view = textureViews[handle];
    wgpuTextureViewRelease(texture_view.texture_view);
 
    textureViews.removeResource(handle);
  }
 
  SamplerStateHandle TexturesWebGPU::loadSamplerState(const SamplerState &state)
  {
    WGPUDevice device = graphicsDevice->device;
 
    SamplerStateWebGPU sampler = {};
 
    WGPUSamplerDescriptor desc = {};
    desc.addressModeU = wgpu(state.addressModeS);
    desc.addressModeV = wgpu(state.addressModeT);
    desc.addressModeW = wgpu(state.addressModeW);
    switch(state.filter){
    case SamplerState::FilterMode::MinMagMipPoint:
      desc.magFilter = WGPUFilterMode_Nearest;
      desc.minFilter = WGPUFilterMode_Nearest;
      desc.mipmapFilter = WGPUMipmapFilterMode_Nearest;
      desc.compare = WGPUCompareFunction_Undefined;
      break;
    case SamplerState::FilterMode::MinMagMipLinear:
      desc.magFilter = WGPUFilterMode_Linear;
      desc.minFilter = WGPUFilterMode_Linear;
      desc.mipmapFilter = WGPUMipmapFilterMode_Linear;
      desc.compare = WGPUCompareFunction_Undefined;
      break;
    case SamplerState::FilterMode::ComparisonMinMagMipPoint:
      desc.magFilter = WGPUFilterMode_Nearest;
      desc.minFilter = WGPUFilterMode_Nearest;
      desc.mipmapFilter = WGPUMipmapFilterMode_Nearest;
      desc.compare = wgpu(state.comparisonFunction);
      break;
    case SamplerState::FilterMode::ComparisonMinMagMipLinear:
      desc.magFilter = WGPUFilterMode_Linear;
      desc.minFilter = WGPUFilterMode_Linear;
      desc.mipmapFilter = WGPUMipmapFilterMode_Linear;
      desc.compare = wgpu(state.comparisonFunction);
      break;
    default:
      assert(false);
      break;
    }
    desc.lodMinClamp = 0;
    desc.lodMaxClamp = 32;
    if(state.maxAnisotropy < 1.0f)
      desc.maxAnisotropy = 1;
    else
      desc.maxAnisotropy = (uint16_t)state.maxAnisotropy;
    if ((desc.minFilter == WGPUFilterMode_Nearest || desc.magFilter == WGPUFilterMode_Nearest) && desc.maxAnisotropy > 1) {
      LOG_WARNING(logger, "Sampler with nearest filter must set maxAnisotropy = 1");
      desc.maxAnisotropy = 1;
    }
    sampler.sampler = wgpuDeviceCreateSampler(device, &desc);
 
    return samplerStates.addResource(std::move(sampler));
  }
 
  void TexturesWebGPU::releaseSamplerState(SamplerStateHandle handle)
  {
    if(!HandleIsValid(handle)) return;
 
    SamplerStateWebGPU &sampler = samplerStates[handle];
    wgpuSamplerRelease(sampler.sampler);
 
    samplerStates.removeResource(handle);
  }
 
  void TexturesWebGPU::generateMipmaps(TextureHandle /*handle*/)
  {
    // TODO
  }
 
  void TexturesWebGPU::releaseResources()
  {
    // TODO
  }
 
}