vtkWebGPUComputePassBufferStorageInternals.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause

#ifndef vtkWebGPUComputePassBufferStorageInternals_h
#define vtkWebGPUComputePassBufferStorageInternals_h

#include "vtkObject.h"
#include "vtkSmartPointer.h"              // for smart pointers
#include "vtkWeakPointer.h"               // for weak pointers
#include "vtkWebGPUComputeBuffer.h"       // for compute buffers
#include "vtkWebGPUComputePass.h"         // for enum
#include "vtkWebGPUComputeRenderBuffer.h" // for compute render buffers
#include "vtkWebGPUConfiguration.h"       // for ivar
#include "vtk_wgpu.h"                     // for webgpu

VTK_ABI_NAMESPACE_BEGIN

class vtkWebGPUComputePassBufferStorageInternals : public vtkObject
{
public:
  static vtkWebGPUComputePassBufferStorageInternals* New();
  vtkTypeMacro(vtkWebGPUComputePassBufferStorageInternals, vtkObject);

  enum UpdateBufferStatusCode
  {
    SUCCESS = 0,
    UP_TO_DATE,
    BUFFER_NOT_FOUND
  };

  vtkSetSmartPointerMacro(ParentPassWGPUConfiguration, vtkWebGPUConfiguration);

  void SetComputePass(vtkWeakPointer<vtkWebGPUComputePass> parentComputePass);

  int AddBuffer(vtkSmartPointer<vtkWebGPUComputeBuffer> buffer);

  wgpu::Buffer GetWGPUBuffer(std::size_t bufferIndex);

  void AddRenderBuffer(vtkSmartPointer<vtkWebGPUComputeRenderBuffer> renderBuffer);

  unsigned int GetBufferByteSize(std::size_t bufferIndex);

  void ResizeBuffer(std::size_t bufferIndex, vtkIdType newByteSize);

  void RecreateBuffer(std::size_t bufferIndex, vtkIdType newByteSize);

  /*
   * This function maps the buffer, making it accessible to the CPU. This is
   * an asynchronous operation, meaning that the given callback will be called
   * when the mapping is done.
   *
   * The buffer data can then be read from the callback and stored
   * in a buffer (std::vector<>, vtkDataArray, ...) passed in via the userdata pointer for example
   */
  void ReadBufferFromGPU(
    std::size_t bufferIndex, vtkWebGPUComputePass::BufferMapAsyncCallback callback, void* userdata);

  UpdateBufferStatusCode UpdateWebGPUBuffer(vtkSmartPointer<vtkWebGPUComputeBuffer> buffer,
    wgpu::Buffer wgpuBuffer, std::size_t& outBufferIndex);

  void WriteBuffer(std::size_t bufferIndex, const void* bytes, std::size_t numBytes)
  {
    vtkWebGPUComputeBuffer* buffer = this->Buffers[bufferIndex];
    vtkIdType byteSize = buffer->GetByteSize();
    vtkIdType givenSize = numBytes;

    if (givenSize > byteSize)
    {
      vtkLog(ERROR,
        "void* data given to UpdateBufferData with index "
          << bufferIndex << " is too big. " << givenSize
          << "bytes were given but the buffer is only " << byteSize
          << " bytes long. No data was updated by this call.");

      return;
    }

    wgpu::Buffer wgpuBuffer = this->WebGPUBuffers[bufferIndex];
    this->ParentPassWGPUConfiguration->WriteBuffer(wgpuBuffer, 0, bytes, numBytes);
  }

  void WriteBuffer(
    std::size_t bufferIndex, vtkIdType byteOffset, const void* bytes, std::size_t numBytes)
  {
    vtkWebGPUComputeBuffer* buffer = this->Buffers[bufferIndex];
    vtkIdType byteSize = buffer->GetByteSize();
    vtkIdType givenSize = numBytes;

    if (givenSize + byteOffset > byteSize)
    {
      vtkLog(ERROR,
        "void* data given to WriteBuffer with index "
          << bufferIndex << " and offset " << byteOffset << " is too big. " << givenSize
          << "bytes and offset " << byteOffset << " were given but the buffer is only " << byteSize
          << " bytes long. No data was updated by this call.");

      return;
    }

    wgpu::Buffer wgpuBuffer = this->WebGPUBuffers[bufferIndex];
    this->ParentPassWGPUConfiguration->WriteBuffer(wgpuBuffer, byteOffset, bytes, numBytes);
  }

  void UpdateBufferData(std::size_t bufferIndex, vtkDataArray* newData);

  void UpdateBufferData(std::size_t bufferIndex, vtkIdType byteOffset, vtkDataArray* newData);

  bool CheckBufferIndex(std::size_t bufferIndex, const std::string& callerFunctionName);

  bool CheckBufferCorrectness(vtkSmartPointer<vtkWebGPUComputeBuffer> buffer);

  void SetupRenderBuffer(vtkSmartPointer<vtkWebGPUComputeRenderBuffer> renderBuffer);

  void ReleaseResources();

  static wgpu::BufferUsage ComputeBufferModeToBufferUsage(vtkWebGPUComputeBuffer::BufferMode mode);

  static wgpu::BufferBindingType ComputeBufferModeToBufferBindingType(
    vtkWebGPUComputeBuffer::BufferMode mode);

protected:
  vtkWebGPUComputePassBufferStorageInternals() = default;
  ~vtkWebGPUComputePassBufferStorageInternals() override;

private:
  friend class vtkWebGPUComputePassInternals;

  vtkWebGPUComputePassBufferStorageInternals(
    const vtkWebGPUComputePassBufferStorageInternals&) = delete;
  void operator=(const vtkWebGPUComputePassBufferStorageInternals&) = delete;

  // Compute pass that uses this buffer storage
  vtkWeakPointer<vtkWebGPUComputePass> ParentComputePass;
  // Device of the parent compute pass that is used when creating buffers
  vtkSmartPointer<vtkWebGPUConfiguration> ParentPassWGPUConfiguration;

  // Compute buffers
  std::vector<vtkSmartPointer<vtkWebGPUComputeBuffer>> Buffers;
  // WebGPU buffers associated with the compute buffers, in the same order
  std::vector<wgpu::Buffer> WebGPUBuffers;
};

#endif

VTK_ABI_NAMESPACE_END