vtkWebGPUConfiguration.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 vtkWebGPUConfiguration_h
#define vtkWebGPUConfiguration_h
 
#include "vtkObject.h"
 
#include "vtkCommand.h"               // for vtkCommand
#include "vtkLogger.h"                // for vtkLogger::Verbosity enum
#include "vtkRenderingWebGPUModule.h" // for export macro
#include "vtkWrappingHints.h"         // For VTK_MARSHALAUTO
#include "vtk_wgpu.h"                 // for wgpu
 
#include <memory> // for unique_ptr
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPURenderWindow;
class vtkWebGPUComputePipeline;
class vtkWebGPUConfigurationInternals;
 
class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO vtkWebGPUConfiguration : public vtkObject
{
public:
  static vtkWebGPUConfiguration* New();
  vtkTypeMacro(vtkWebGPUConfiguration, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum class PowerPreferenceType
  {
    Undefined,
    LowPower,
    HighPerformance
  };
 
  enum class BackendType
  {
    Undefined,
    Null,
    WebGPU,
    D3D11,
    D3D12,
    Metal,
    Vulkan,
    OpenGL,
    OpenGLES
  };


  vtkSetEnumMacro(PowerPreference, PowerPreferenceType);
  vtkGetEnumMacro(PowerPreference, PowerPreferenceType);


  vtkSetEnumMacro(Backend, BackendType);
  vtkGetEnumMacro(Backend, BackendType);


  vtkSetMacro(Timeout, double);
  vtkGetMacro(Timeout, double);

  static void SetDefaultTimeout(double);

  BackendType GetBackendInUse();

  std::string GetBackendInUseAsString();


  wgpu::Adapter GetAdapter();
  wgpu::Device GetDevice();
  wgpu::Instance GetInstance();

  VTK_MAYSUSPEND
  bool Initialize();

  void FinalizeDevice();

  void Finalize();

  VTK_MAYSUSPEND
  void ProcessEvents();

  static std::size_t Align(std::size_t value, std::size_t alignment);
 
  enum
  {
    AdapterRequestCompletedEvent = vtkCommand::UserEvent,
    DeviceRequestCompletedEvent,
  };

  std::string ReportCapabilities();
  static std::string DeviceNotReadyMessage();

  std::uint32_t GetAdapterVendorID();
  std::uint32_t GetAdapterDeviceID();


  bool IsAMDGPUInUse();
  bool IsAppleGPUInUse();
  bool IsARMGPUInUse();
  bool IsBroadcomGPUInUse();
  bool IsIntelGPUInUse();
  bool IsMesaGPUInUse();
  bool IsMicrosoftGPUInUse();
  bool IsNVIDIAGPUInUse();
  bool IsSamsungGPUInUse();


  wgpu::Buffer CreateBuffer(std::uint64_t sizeBytes, wgpu::BufferUsage usage,
    bool mappedAtCreation = false, const char* label = nullptr);
  wgpu::Buffer CreateBuffer(const wgpu::BufferDescriptor& bufferDescriptor);

  void WriteBuffer(const wgpu::Buffer& buffer, std::uint64_t offset, const void* data,
    std::size_t sizeBytes, const char* description = nullptr);


  wgpu::Texture CreateTexture(wgpu::Extent3D extents, wgpu::TextureDimension dimension,
    wgpu::TextureFormat format, wgpu::TextureUsage usage, int mipLevelCount = 1,
    const char* label = nullptr);
  wgpu::Texture CreateTexture(const wgpu::TextureDescriptor& textureDescriptor);

  wgpu::TextureView CreateView(wgpu::Texture texture, wgpu::TextureViewDimension dimension,
    wgpu::TextureAspect aspect, wgpu::TextureFormat format, int baseMipLevel, int mipLevelCount,
    const char* label = nullptr);
  wgpu::TextureView CreateView(
    wgpu::Texture texture, const wgpu::TextureViewDescriptor& viewDescriptor);

  void WriteTexture(wgpu::Texture texture, uint32_t bytesPerRow, uint32_t byteSize,
    const void* data, uint32_t srcOffset = 0, wgpu::Origin3D dstOffset = { 0, 0, 0 },
    uint32_t dstMipLevel = 0, const char* description = nullptr);


  void SetGPUMemoryLogVerbosity(vtkLogger::Verbosity verbosity);
  vtkLogger::Verbosity GetGPUMemoryLogVerbosity();

  void DumpMemoryStatistics();
 
protected:
  vtkWebGPUConfiguration();
  ~vtkWebGPUConfiguration() override;
 
private:
  vtkWebGPUConfiguration(const vtkWebGPUConfiguration&) = delete;
  void operator=(const vtkWebGPUConfiguration&) = delete;
 
  friend class vtkWebGPUConfigurationInternals;
  std::unique_ptr<vtkWebGPUConfigurationInternals> Internals;
 
  PowerPreferenceType PowerPreference = PowerPreferenceType::HighPerformance;
  // Initialized in constructor at runtime based on the operating system.
  BackendType Backend;
  // In milliseconds
  double Timeout;
 
  vtkLogger::Verbosity GPUMemoryLogVerbosity = vtkLogger::VERBOSITY_INVALID;
  // Tracks whether AddInstanceRef() was called so Finalize() can release it
  // even after FinalizeDevice() has already set DeviceReady=false.
  bool InstanceRefHeld = false;
};
 
VTK_ABI_NAMESPACE_END
 
#endif