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 webgpu C API
 
#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();


  WGPUAdapter GetAdapter();
  WGPUDevice GetDevice();
  WGPUInstance GetInstance();

  VTK_MAYSUSPEND
  bool Initialize();

  void FinalizeDevice();

  void Finalize();

  VTK_MAYSUSPEND
  void ProcessEvents();


  void IncrementActiveBufferMapCount() { ++this->ActiveBufferMapCount; }
  void DecrementActiveBufferMapCount() { --this->ActiveBufferMapCount; }
  int GetActiveBufferMapCount() const { return this->ActiveBufferMapCount; }

  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();

  void DeferBufferRelease(WGPUBuffer buffer);


  WGPUBuffer CreateBuffer(std::uint64_t sizeBytes, WGPUBufferUsage usage,
    bool mappedAtCreation = false, const char* label = nullptr);
  WGPUBuffer CreateBuffer(const WGPUBufferDescriptor& bufferDescriptor);

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


  WGPUTexture CreateTexture(WGPUExtent3D extents, WGPUTextureDimension dimension,
    WGPUTextureFormat format, WGPUTextureUsage usage, int mipLevelCount = 1,
    const char* label = nullptr);
  WGPUTexture CreateTexture(const WGPUTextureDescriptor& textureDescriptor);

  WGPUTextureView CreateView(WGPUTexture texture, WGPUTextureViewDimension dimension,
    WGPUTextureAspect aspect, WGPUTextureFormat format, int baseMipLevel, int mipLevelCount,
    const char* label = nullptr);
  WGPUTextureView CreateView(WGPUTexture texture, const WGPUTextureViewDescriptor& viewDescriptor);

  void WriteTexture(WGPUTexture texture, uint32_t bytesPerRow, uint32_t byteSize, const void* data,
    uint32_t srcOffset = 0, WGPUOrigin3D 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;
 
  // Number of in-flight asynchronous buffer map (readback) operations. See
  // IncrementActiveBufferMapCount().
  int ActiveBufferMapCount = 0;
 
  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