vtkWebGPUComputeBuffer.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 vtkWebGPUComputeBuffer_h
#define vtkWebGPUComputeBuffer_h

#include "vtkDataArray.h" // for vtkDataArray used in SetData
#include "vtkLogger.h"    // for the logger
#include "vtkObject.h"
#include "vtkRenderingWebGPUModule.h" // For export macro
#include "vtkSetGet.h"                // for get/set macro
#include "vtk_wgpu.h"                 // for dawn classes

#include <functional>
#include <string>

VTK_ABI_NAMESPACE_BEGIN

class vtkWebGPUComputePass;
class vtkWebGPURenderer;

class VTKRENDERINGWEBGPU_EXPORT vtkWebGPUComputeBuffer : public vtkObject
{
public:
  vtkTypeMacro(vtkWebGPUComputeBuffer, vtkObject);
  static vtkWebGPUComputeBuffer* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum BufferMode
  {
    UNDEFINED = 0,
    READ_ONLY_COMPUTE_STORAGE,
    READ_WRITE_COMPUTE_STORAGE,
    READ_WRITE_MAP_COMPUTE_STORAGE,
    UNIFORM_BUFFER
  };

  enum BufferDataType
  {
    VTK_DATA_ARRAY = 0,
    STD_VECTOR
  };


  vtkGetEnumMacro(Mode, BufferMode);
  vtkSetEnumMacro(Mode, BufferMode);


  uint32_t GetGroup() const { return this->Group; }
  vtkGetMacro(Group, vtkIdType);
  vtkSetMacro(Group, vtkIdType);


  uint32_t GetBinding() const { return this->Binding; }
  vtkGetMacro(Binding, vtkIdType);
  vtkSetMacro(Binding, vtkIdType);


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

  template <typename T>
  void SetData(const std::vector<T>& data)
  {
    this->DataPointer = data.data();
    this->ByteSize = data.size() * sizeof(T);
  }

  void SetData(vtkDataArray* data);


  vtkGetMacro(DataType, BufferDataType);
  vtkSetMacro(DataType, BufferDataType);

  const void* GetDataPointer() { return this->DataPointer; }

  vtkDataArray* GetDataArray() { return this->DataArray; }


  vtkGetMacro(ByteSize, vtkIdType);
  vtkSetMacro(ByteSize, vtkIdType);

protected:
  vtkWebGPUComputeBuffer();
  ~vtkWebGPUComputeBuffer() override;

private:
  friend class vtkWebGPUComputePass;

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

  // Bind group index
  vtkIdType Group = -1;
  // Binding within the bind group
  vtkIdType Binding = -1;
  // The mode of the buffer can be read only, write only, read/write, ...
  BufferMode Mode = BufferMode::UNDEFINED;
  // The type of data that will be uploaded to the GPU
  BufferDataType DataType = BufferDataType::STD_VECTOR;

  // Pointer to the data that this buffer will contain. This variable DataPointer is only used when
  // the user set the buffer data (with SetData()) using an std::vector.
  const void* DataPointer = nullptr;
  // Data array containing the data that will be uploaded to the buffer. Only relevant if the user
  // called SetData(vtkDataArray).
  vtkDataArray* DataArray = nullptr;
  // How many bytes will be uploaded from the buffer to the GPU
  vtkIdType ByteSize = 0;
  // Label that can be used to identify this buffer and help with debugging
  // in case something goes wrong
  std::string Label;
};

VTK_ABI_NAMESPACE_END
#endif