vtkWebGPUComputePass.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 vtkWebGPUComputePass_h
#define vtkWebGPUComputePass_h

#include "vtkObject.h"

#include "vtkRenderingWebGPUModule.h" // For export macro
#include "vtkSmartPointer.h"          // for arg
#include "vtk_wgpu.h"                 // for webgpu

#include <type_traits> // for enable_if_t

class vtkDataArray;
class vtkWebGPUComputeBuffer;
class vtkWebGPUComputePipeline;
class vtkWebGPUComputeRenderBuffer;
class vtkWebGPUComputeRenderTexture;
class vtkWebGPUComputeTexture;
class vtkWebGPUComputeTextureView;
class vtkWebGPUComputePassInternals;
class vtkWebGPUComputePassBufferStorageInternals;
class vtkWebGPUComputePassTextureStorageInternals;

VTK_ABI_NAMESPACE_BEGIN

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

  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkGetMacro(ShaderSource, std::string);
  vtkSetMacro(ShaderSource, std::string);

  void SetShaderSourceFromPath(const char* shaderFilePath);


  vtkGetMacro(ShaderEntryPoint, std::string);
  vtkSetMacro(ShaderEntryPoint, std::string);


  vtkGetMacro(Label, std::string&);
  void SetLabel(const std::string& label);

  int AddBuffer(vtkSmartPointer<vtkWebGPUComputeBuffer> buffer);

  void AddRenderBuffer(vtkSmartPointer<vtkWebGPUComputeRenderBuffer> renderBuffer);

  int AddRenderTexture(vtkSmartPointer<vtkWebGPUComputeRenderTexture> renderTexture);

  int AddTexture(vtkSmartPointer<vtkWebGPUComputeTexture> texture);

  vtkSmartPointer<vtkWebGPUComputeTextureView> CreateTextureView(int textureIndex);

  int AddTextureView(vtkSmartPointer<vtkWebGPUComputeTextureView> textureView);

  void RebindTextureView(int group, int binding, int textureViewIndex);

  void DeleteTextureViews(int textureIndex);

  unsigned int GetBufferByteSize(int bufferIndex);

  void ResizeBuffer(int bufferIndex, vtkIdType newByteSize);

  vtkSmartPointer<vtkWebGPUComputeTexture> GetComputeTexture(int textureIndex);

  vtkSmartPointer<vtkWebGPUComputeTextureView> GetTextureView(int textureViewIndex);

  void RecreateComputeTexture(int textureIndex);

  void RecreateTextureView(int textureViewIndex);

  /*
   * Callback called when the asynchronous mapping of a buffer is done
   * and data is ready to be copied.
   * This callback takes three parameters:
   *
   * - A first void pointer to the data mapped from the GPU ready to be copied
   * - A second void pointer pointing to user data, which can essentially be anything
   *      needed by the callback to copy the data to the CPU
   */
  using BufferMapAsyncCallback = std::function<void(const void*, void*)>;

  /*
   * 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(int bufferIndex, BufferMapAsyncCallback callback, void* userdata);

  /*
   * Callback called when the asynchronous mapping of a texture is done
   * and data is ready to be copied.
   * This callback takes three parameters:
   *
   * - A void pointer to the data mapped from the GPU ready to be copied.
   *
   * - An integer representing how many bytes per row the mapped data contains. This is
   * useful because some padding has probably be done on the buffer to satisfy WebGPU size
   * constraints. At the time of writing, buffers for texture mapping need a number of bytes per row
   * that is a multiple of 256 bytes. This means that for a texture of 300x300 RGBA (300 * 4 = 1200
   * bytes per row), there will be 80 bytes of additional padding to achieve 1280 bytes per row
   * which is a multiple of 256. In this case, the integer argument of the callback will contain the
   * value '1280' and it is then the responsibility of the user to only read relevant data (i.e. the
   * 1200 first bytes of each row since the 80 last bytes are irrelevant padding).
   *
   * - A second void pointer pointing to user data, which can essentially be anything
   *      needed by the callback to copy the data to the CPU
   */
  using TextureMapAsyncCallback = std::function<void(const void*, int, void*)>;

  void ReadTextureFromGPU(
    int textureIndex, int mipLevel, TextureMapAsyncCallback callback, void* userdata);

  template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, bool> = true>
  void UpdateBufferData(int bufferIndex, const std::vector<T>& newData)
  {
    this->WriteBufferData(bufferIndex, 0, newData.data(), newData.size() * sizeof(T));
  }

  template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, bool> = true>
  void UpdateBufferData(int bufferIndex, vtkIdType byteOffset, const std::vector<T>& data)
  {
    this->WriteBufferData(bufferIndex, byteOffset, data.data(), data.size() * sizeof(T));
  }

  void UpdateBufferData(int bufferIndex, vtkDataArray* newData);

  void UpdateBufferData(int bufferIndex, vtkIdType byteOffset, vtkDataArray* newData);

  template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, bool> = true>
  void UpdateTextureData(int textureIndex, const std::vector<T>& data)
  {
    this->WriteTextureData(textureIndex, data.data(), data.size() * sizeof(T));
  }

  /*
   * Set/get the number of workgroups in each dimension that are used by each Dispatch() call.
   */
  void SetWorkgroups(int groupsX, int groupsY, int groupsZ);

  void Dispatch();

  void ReleaseResources();

protected:
  vtkWebGPUComputePass();
  ~vtkWebGPUComputePass() override;

private:
  vtkWebGPUComputePass(const vtkWebGPUComputePass&) = delete;
  void operator=(const vtkWebGPUComputePass&) = delete;

  void WriteBufferData(
    int bufferIndex, vtkIdType byteOffset, const void* data, std::size_t numBytes);

  void WriteTextureData(int textureIndex, const void* data, std::size_t numBytes);

  friend class vtkWebGPUComputePassInternals;
  friend class vtkWebGPUComputePassTextureStorageInternals;
  friend class vtkWebGPUComputePassBufferStorageInternals;
  friend class vtkWebGPUComputePipeline;
  friend class vtkWebGPUHelpers;
  // For the mapper to be able to access the internals to access the wgpu::Buffer objects for use
  // in a render pipeline
  friend class vtkWebGPUPointCloudMapperInternals;
  friend class vtkWebGPURenderWindow;
  friend class vtkWebGPURenderer;

  std::string ShaderSource;
  std::string ShaderEntryPoint;

  // How many groups to launch when dispatching the compute
  unsigned int GroupsX = 0, GroupsY = 0, GroupsZ = 0;

  // Label used for the wgpu compute pipeline of this VTK compute pipeline
  std::string Label = "WebGPU compute pass";

  // Label used for the wgpu command encoders created and used by this VTK compute pipeline
  std::string WGPUCommandEncoderLabel = "WebGPU command encoder \"" + this->Label + "\"";
  std::string WGPUComputePipelineLabel = "WebGPU pipeline \"" + this->Label + "\"";

  // Internal implementation of the compute pass
  vtkSmartPointer<vtkWebGPUComputePassInternals> Internals;
};

VTK_ABI_NAMESPACE_END

#endif