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");
}
 
namespace Cogs{
 
  void BufferWebGPU::CreateInstance(GraphicsDeviceWebGPU *graphicsDevice)
  {
    WGPUBufferDescriptor desc = {};
    desc.label = nullptr;
    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;
 
    buffer = wgpuDeviceCreateBuffer(graphicsDevice->device, &desc);
    if(!is_read_buffer){
      alias.push_back(buffer);
    }
  }
  void BufferWebGPU::NextInstance(GraphicsDeviceWebGPU *graphicsDevice)
  {
    uint32_t idx = alias_idx;
    alias_idx++;
    if(idx >= alias.size()){
      CreateInstance(graphicsDevice);
      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();
    }
  }
 
  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 = WGPUVertexFormat_Undefined;
        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{
          WGPUVertexAttribute &att = input_layout.vertex_attributes[attribute_offset++];
          att.format = VertexFormatsWebGPU[(size_t)element.format];
          if (semantic.format != VertexFormatsWebGPU[(size_t)element.format]) {
            LOG_WARNING(logger, "Inconsisten vertex attribute format");
          }
          assert(att.format != WGPUVertexFormat_Undefined); // 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);
    if(data){
      wgpuQueueWriteBuffer(graphicsDevice->queue, buffer.buffer, 0, data, buffer.size);
    }
 
    return this->buffers.addResource(std::move(buffer));
  }
 
  void BuffersWebGPU::releaseBuffer(BufferHandle handle)
  {
    if(!buffers[handle].is_read_buffer){
      wgpuBufferRelease(buffers[handle].buffer);
    }
    else{
      for(WGPUBuffer &buffer: buffers[handle].alias){
        wgpuBufferRelease(buffer);
      }
    }
    buffers.removeResource(handle);
  }
 
  void* BuffersWebGPU::getNativeHandle(BufferHandle handle)
  {
    return static_cast<void*>(buffers[handle].buffer);
  }
 
}