BuffersWebGPU.cpp

#include "BuffersWebGPU.h"
 
#include "FormatsWebGPU.h"
#include "GraphicsDeviceWebGPU.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BuffersWebGPU");
 
  void buffer_error_callback(WGPUPopErrorScopeStatus status, WGPUErrorType type, WGPUStringView message, void* userdata1, void* userdata2)
  {
    Cogs::BufferWebGPU *buffer = (Cogs::BufferWebGPU*)userdata1;
    (void)buffer;
    Cogs::GraphicsDeviceWebGPU *ptr = (Cogs::GraphicsDeviceWebGPU*)userdata2;
    (void)ptr;
    if(status == WGPUPopErrorScopeStatus_CallbackCancelled){
      LOG_ERROR(logger, "WebGPU buffer err status: Cancelled");
    }
    if(status == WGPUPopErrorScopeStatus_Error){
      LOG_ERROR(logger, "WebGPU buffer err status: Error");
    }
    if(message.data && message.length){
      LOG_ERROR(logger, "WebGPU buffer err (%d) %.*s", type, WGPUStringViewFormat(message));
    }
  }
}
 
namespace Cogs{
 
  void BufferWebGPU::CreateInstance(GraphicsDeviceWebGPU *graphicsDevice, BuffersWebGPU & /*buffers*/)
  {
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    WGPUBufferDescriptor desc = WGPU_BUFFER_DESCRIPTOR_INIT;
    desc.label.length = WGPU_STRLEN;
    if(label.length()){
      desc.label.data = label.data();
      desc.label.length = label.length();
    }
    if(accessMode&AccessMode::Read){
      desc.usage |= WGPUBufferUsage_MapRead;
      desc.usage |= WGPUBufferUsage_CopyDst;
    }
    else{
      desc.usage |= WGPUBufferUsage_CopyDst;
    }
 
    if((bindFlags&BindFlags::VertexBuffer) != 0)
      desc.usage |= WGPUBufferUsage_Vertex;
    if((bindFlags&BindFlags::IndexBuffer) != 0)
      desc.usage |= WGPUBufferUsage_Index;
    if((bindFlags&BindFlags::ConstantBuffer) != 0)
      desc.usage |= WGPUBufferUsage_Uniform;
    if((bindFlags&BindFlags::ShaderResource) != 0)
      desc.usage |= WGPUBufferUsage_Storage;
    if((bindFlags&BindFlags::RawBuffer) != 0)
      desc.usage |= WGPUBufferUsage_Storage;
    if((bindFlags&BindFlags::StructuredBuffer) != 0)
      desc.usage |= WGPUBufferUsage_Storage;
    if((bindFlags&BindFlags::StructuredBufferWithCounter) != 0)
      desc.usage |= WGPUBufferUsage_Storage;
 
    desc.size = size;
    desc.mappedAtCreation = false;
 
    if(graphicsDevice->use_error_scope){
      wgpuDevicePushErrorScope(graphicsDevice->device, graphicsDevice->filter);
    }
 
    buffer = wgpuDeviceCreateBuffer(graphicsDevice->device, &desc);
    counters.buffer++;
    if(!is_read_buffer){
      alias.push_back(buffer);
    }
 
    if(graphicsDevice->use_error_scope){
      WGPUPopErrorScopeCallbackInfo info = WGPU_POP_ERROR_SCOPE_CALLBACK_INFO_INIT;
      info.mode = WGPUCallbackMode_AllowSpontaneous;
      info.callback = buffer_error_callback;
      info.userdata1 = this;
      info.userdata2 = graphicsDevice;
      WGPUFuture future = wgpuDevicePopErrorScope(graphicsDevice->device, info);
      // WGPUWaitStatus wgpuInstanceWaitAny(WGPUInstance instance, size_t futureCount, WGPUFutureWaitInfo * futures, uint64_t timeoutNS);
    }
  }
  void BufferWebGPU::NextInstance(GraphicsDeviceWebGPU *graphicsDevice, BuffersWebGPU &buffers)
  {
    uint32_t idx = alias_idx;
    alias_idx++;
    assert(idx < 1024);
    if(idx >= alias.size()){
      CreateInstance(graphicsDevice, buffers);
      assert(idx+1 == alias.size());
    }
    else{
      buffer = alias[idx];
    }
  }
  void BufferWebGPU::ResetInstance()
  {
    // TODO: this is an oppertunity to free unused aliases and save memory
    alias_idx = 0;
  }
 
  void BuffersWebGPU::initialize(GraphicsDeviceWebGPU *device)
  {
    graphicsDevice = device;
  }
  void BuffersWebGPU::resetInstances()
  {
    for(BufferWebGPU &buffer : buffers){
      buffer.ResetInstance();
    }
  }
 
  void BuffersWebGPU::annotate(BufferHandle handle, const StringView& name)
  {
    BufferWebGPU &buffer = buffers[handle];
    buffer.label = std::string(name.data(), name.length());
 
    WGPUStringView label;
    label.data = buffer.label.data();
    label.length = buffer.label.length();
 
    if(buffer.is_read_buffer){
      wgpuBufferSetLabel(buffer.buffer, label);
    }
    else{
      for(WGPUBuffer &alias: buffer.alias){
        wgpuBufferSetLabel(alias, label);
      }
    }
  }
  void BuffersWebGPU::annotate(VertexBufferHandle handle, const StringView& name)
  {
    annotate((BufferHandle)handle, name);
  }
 
  VertexBufferHandle BuffersWebGPU::loadVertexBuffer(const void* vertexData, const size_t count, const VertexFormat& vertexFormat)
  {
    const uint32_t stride = getSize(vertexFormat);
    const size_t size = count * stride;
    auto handle = loadBuffer(vertexData, size, Usage::Dynamic, AccessMode::None, BindFlags::VertexBuffer);
    return handle;
  }
 
  VertexBufferHandle BuffersWebGPU::loadVertexBuffer(const void* vertexData, const size_t count, VertexFormatHandle vertexFormatHandle)
  {
    return loadVertexBuffer(vertexData, count, *VertexFormats::getVertexFormat(vertexFormatHandle));
  }
 
  void BuffersWebGPU::releaseVertexBuffer(VertexBufferHandle handle)
  {
    buffers.removeResource(handle);
  }
 
  IndexBufferHandle BuffersWebGPU::loadIndexBuffer(const void* indexData, const size_t count, const size_t indexSize)
  {
    const size_t size = count * indexSize;
    auto handle = loadBuffer(indexData, size, Usage::Dynamic, AccessMode::None, BindFlags::IndexBuffer);
    return handle;
  }
 
  void BuffersWebGPU::releaseIndexBuffer(IndexBufferHandle handle)
  {
    buffers.removeResource(handle);
  }
 
  InputLayoutHandle BuffersWebGPU::loadInputLayout(const VertexFormatHandle* vertexFormats, const size_t count, EffectHandle effectHandle)
  {
    size_t attribute_count = 0;
    for(size_t i=0; i<count; i++){
      const VertexFormat *vtx_format = getVertexFormat(vertexFormats[i]);
      for(size_t j=0; j<vtx_format->elements.size(); j++){
        const VertexElement &element = vtx_format->elements[j];
        if(element.format == DataFormat::MAT4X4_FLOAT){
          attribute_count += 4;
        }
        else{
          attribute_count += 1;
        }
      }
    }
 
    InputLayoutWebGPU input_layout = {};
    input_layout.vertex_attributes.resize(attribute_count);
    input_layout.vertex_buffer_layout.resize(count);
 
    size_t attribute_offset = 0;
    for(size_t i=0; i<count; i++){
      const VertexFormat *vtx_format = getVertexFormat(vertexFormats[i]);
      WGPUVertexBufferLayout &vtx_layout = input_layout.vertex_buffer_layout[i];
      vtx_layout.arrayStride = getSize(*vtx_format);
      if(vtx_format->elements[0].inputType == InputType::VertexData){
        vtx_layout.stepMode = WGPUVertexStepMode_Vertex;
      }
      else if(vtx_format->elements[0].inputType == InputType::InstanceData){
        vtx_layout.stepMode = WGPUVertexStepMode_Instance;
      }
      else{
        // vtx_layout.stepMode = WGPUVertexStepMode_VertexBufferNotUsed;
        assert(false);
      }
      vtx_layout.attributeCount = 0;
      vtx_layout.attributes = vtx_format->elements.size() ? &input_layout.vertex_attributes[attribute_offset] : nullptr;
      for(size_t j=0; j<vtx_format->elements.size(); j++){
        const VertexElement &element = vtx_format->elements[j];
        if(vtx_layout.stepMode == WGPUVertexStepMode_Vertex){
          assert(element.inputType == InputType::VertexData);
          assert(element.instanceStep == 0);
        }
        else if(vtx_layout.stepMode == WGPUVertexStepMode_Instance){
          assert(element.inputType == InputType::InstanceData);
          assert(element.instanceStep == 1);
        }
        else{
          assert(false);
        }
        EffectWebGPU& effect = graphicsDevice->effects.effects[effectHandle];
 
        uint32_t attribute_location = std::numeric_limits<uint32_t>::max();
        SemanticSlotBinding semantic = {};
        semantic.format = static_cast<WGPUVertexFormat>(0);
        for (size_t s = 0; s < effect.num_attribs; s++) {
          const SemanticSlotBinding& sem = effect.semanticSlotBindings[s];
          if (sem.semantic == size_t(element.semantic) && sem.slot == element.semanticIndex) {
            attribute_location = sem.binding;
            semantic = sem;
            break;
          }
        }
        if (attribute_location == std::numeric_limits<uint32_t>::max()) {
          LOG_WARNING(logger, "Vertex attribute semantic %d, slot %d not used in shader", (int)element.semantic, element.semanticIndex);
        }
        if(element.format == DataFormat::MAT4X4_FLOAT){
          for(int k=0; k<4; k++){
            WGPUVertexAttribute &att = input_layout.vertex_attributes[attribute_offset++];
            att.format = WGPUVertexFormat_Float32x4;
            att.offset = element.offset + sizeof(float)*4*k;
            att.shaderLocation = attribute_location+k;
            vtx_layout.attributeCount++;
          }
        }
        else{
          DataFormat format = element.format;
          // WebGPU does not support RGB vertex formats for 8 and 16 byte types.
          // Upgrade these to RGBA formats and hope that the buffer stride is wide enough.
          if(format == DataFormat::R8G8B8_UNORM){
            format = DataFormat::R8G8B8A8_UNORM;
            LOG_WARNING(logger, "Vertex attribute format R8G8B8_UNORM not supported by WebGPU (Using R8G8B8A8_UNORM).");
          }
          else if(format == DataFormat::R8G8B8_SNORM){
            format = DataFormat::R8G8B8A8_SNORM;
            LOG_WARNING(logger, "Vertex attribute format R8G8B8_SNORM not supported by WebGPU (Using R8G8B8A8_SNORM).");
          }
          else if(format == DataFormat::R8G8B8_UINT){
            format = DataFormat::R8G8B8A8_UINT;
            LOG_WARNING(logger, "Vertex attribute format R8G8B8_UINT not supported by WebGPU (Using R8G8B8A8_UINT).");
          }
          else if(format == DataFormat::R8G8B8_SINT){
            format = DataFormat::R8G8B8A8_SINT;
            LOG_WARNING(logger, "Vertex attribute format R8G8B8_SINT not supported by WebGPU (Using R8G8B8A8_SINT).");
          }
          else if(format == DataFormat::R16G16B16_UNORM){
            format = DataFormat::R16G16B16A16_UNORM;
            LOG_WARNING(logger, "Vertex attribute format R16G16B16_UNORM not supported by WebGPU (Using R16G16B16A16_UNORM).");
          }
          else if(format == DataFormat::R16G16B16_SNORM){
            format = DataFormat::R16G16B16A16_SNORM;
            LOG_WARNING(logger, "Vertex attribute format R16G16B16_SNORM not supported by WebGPU (Using R16G16B16A16_SNORM).");
          }
          else if(format == DataFormat::R16G16B16_UINT){
            format = DataFormat::R16G16B16A16_UINT;
            LOG_WARNING(logger, "Vertex attribute format R16G16B16_UINT not supported by WebGPU (Using R16G16B16A16_UINT).");
          }
          else if(format == DataFormat::R16G16B16_SINT){
            format = DataFormat::R16G16B16A16_SINT;
            LOG_WARNING(logger, "Vertex attribute format R16G16B16_SINT not supported by WebGPU (Using R16G16B16A16_SINT).");
          }
          else if(format == DataFormat::R16G16B16_FLOAT){
            format = DataFormat::R16G16B16A16_FLOAT;
            LOG_WARNING(logger, "Vertex attribute format R16G16B16_FLOAT not supported by WebGPU (Using R16G16B16A16_FLOAT).");
          }
          WGPUVertexAttribute &att = input_layout.vertex_attributes[attribute_offset++];
          att.format = VertexFormatsWebGPU[(size_t)format];
          assert(att.format != static_cast<WGPUVertexFormat>(0)); // Vertex format not supported
          att.offset = element.offset;
          att.shaderLocation = attribute_location;
          vtx_layout.attributeCount++;
        }
      }
    }
    assert(attribute_offset == input_layout.vertex_attributes.size());
    return inputLayouts.addResource(std::move(input_layout));
  }
 
  void BuffersWebGPU::releaseInputLayout(InputLayoutHandle inputLayoutHandle)
  {
    inputLayouts.removeResource(inputLayoutHandle);
  }
 
  BufferHandle BuffersWebGPU::loadBuffer(const void* data, const size_t size, Usage::EUsage /*usage*/, uint32_t accessMode, uint32_t bindFlags, uint32_t /*stride*/)
  {
    assert((bindFlags&BindFlags::StreamOutBuffer) == 0);
    assert((accessMode&AccessMode::ReadWrite) != AccessMode::ReadWrite); // Not available for WebGPU
 
    BufferWebGPU buffer = {};
    buffer.size = size;
    buffer.accessMode = accessMode;
    buffer.bindFlags = bindFlags;
 
    if(accessMode&AccessMode::Read){
      buffer.is_read_buffer = true;
      assert(bindFlags == 0);
      // Round up
      size_t granularity = 256;
      if(buffer.size%granularity != 0)
        buffer.size += granularity-buffer.size%granularity;
    }
    else{
      // Round up
      size_t granularity = 16;
      if (buffer.size % granularity != 0)
        buffer.size += granularity - buffer.size % granularity;
    }
 
    buffer.CreateInstance(graphicsDevice, *this);
    if(data){
      wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, data, buffer.size);
    }
 
    const size_t roundedSize = buffer.size;
    BufferHandle handle = this->buffers.addResource(std::move(buffer));
    recordBufferCreate(handle, static_cast<BindFlags::EBindFlags>(bindFlags), roundedSize);
    return handle;
  }
 
  void BuffersWebGPU::releaseBuffer(BufferHandle handle)
  {
    if (!HandleIsValid(handle)) return;
 
    ResourceCountersWebGPU &counters = graphicsDevice->counters;
    BufferWebGPU &buffer = buffers[handle];
    recordBufferRelease(handle, static_cast<BindFlags::EBindFlags>(buffer.bindFlags), buffer.size);
    if(buffer.is_read_buffer){
      wgpuBufferDestroy(buffer.buffer);
      wgpuBufferRelease(buffer.buffer);
      counters.buffer--;
    }
    else{
      for(WGPUBuffer &alias: buffer.alias){
        wgpuBufferDestroy(alias);
        wgpuBufferRelease(alias);
        counters.buffer--;
      }
      buffer.alias.clear();
    }
    buffers.removeResource(handle);
  }
 
  void BuffersWebGPU::releaseResources()
  {
    {
      std::vector<BufferHandle> handles;
      for (auto& resource : buffers) {
        handles.push_back(buffers.getHandle(resource));
      }
      for (auto& handle : handles) {
        releaseBuffer(handle);
      }
    }
    {
      std::vector<InputLayoutHandle> handles;
      for (auto& resource : inputLayouts) {
        handles.push_back(inputLayouts.getHandle(resource));
      }
      for (auto& handle : handles) {
        releaseInputLayout(handle);
      }
    }
  }
 
  void* BuffersWebGPU::getNativeHandle(BufferHandle handle)
  {
    return static_cast<void*>(buffers[handle].buffer);
  }
 
}