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 "vtk_wgpu.h"                 // for wgpu
 
#include <memory> // for unique_ptr
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkWebGPURenderWindow;
class vtkWebGPUComputePipeline;
class vtkWebGPUConfigurationInternals;
 
class VTKRENDERINGWEBGPU_EXPORT 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();
 
  bool Initialize();
 
  void Finalize();
 
  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(unsigned long sizeBytes, wgpu::BufferUsage usage,
    bool mappedAtCreation = false, const char* label = nullptr);
  wgpu::Buffer CreateBuffer(const wgpu::BufferDescriptor& bufferDescriptor);
 
  void WriteBuffer(const wgpu::Buffer& buffer, unsigned long offset, const void* data,
    unsigned long 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, const char* description = nullptr);
 
 
  void SetGPUMemoryLogVerbosity(vtkLogger::Verbosity verbosity);
  vtkLogger::Verbosity GetGPUMemoryLogVerbosity();
 
  void DumpMemoryStatistics();
 
protected:
  vtkWebGPUConfiguration();
  ~vtkWebGPUConfiguration() override;
 
  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;
 
  void AcquireAdapter(vtkObject* caller, unsigned long event, void* calldata);
 
  void AcquireDevice(vtkObject* caller, unsigned long event, void* calldata);
 
private:
  vtkWebGPUConfiguration(const vtkWebGPUConfiguration&) = delete;
  void operator=(const vtkWebGPUConfiguration&) = delete;
 
  friend class vtkWebGPUConfigurationInternals;
  std::unique_ptr<vtkWebGPUConfigurationInternals> Internals;
};
 
VTK_ABI_NAMESPACE_END
 
#endif