vtkWebGPUHandle.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 vtkWebGPUHandle_h
#define vtkWebGPUHandle_h
 
#include "vtkABINamespace.h" // for VTK_ABI_NAMESPACE_BEGIN
#include "vtk_wgpu.h"        // for the WebGPU C API
 
#include <cstddef> // for std::nullptr_t
#include <utility> // for std::swap, std::exchange
 
namespace vtkWebGPU
{
VTK_ABI_NAMESPACE_BEGIN

template <typename T, typename Traits>
class Handle
{
public:
  Handle() = default;

  Handle(std::nullptr_t) {} // NOLINT(google-explicit-constructor)

  static Handle Acquire(T raw)
  {
    Handle handle;
    handle.Raw = raw;
    return handle;
  }

  static Handle Reference(T raw)
  {
    if (raw != nullptr)
    {
      Traits::AddRef(raw);
    }
    return Handle::Acquire(raw);
  }
 
  ~Handle() { this->Reset(); }
 
  Handle(const Handle& other)
    : Raw(other.Raw)
  {
    if (this->Raw != nullptr)
    {
      Traits::AddRef(this->Raw);
    }
  }
 
  Handle(Handle&& other) noexcept
    : Raw(std::exchange(other.Raw, nullptr))
  {
  }

  Handle& operator=(std::nullptr_t)
  {
    this->Reset();
    return *this;
  }
 
  Handle& operator=(Handle other) noexcept
  {
    // Copy-and-swap: `other` is built by the copy or move constructor above, so
    // this handles self-assignment and both value categories in one operator.
    std::swap(this->Raw, other.Raw);
    return *this;
  }

  void Reset()
  {
    if (T raw = std::exchange(this->Raw, nullptr))
    {
      Traits::Release(raw);
    }
  }

  T Release() { return std::exchange(this->Raw, nullptr); }


  T Get() const { return this->Raw; }
  operator T() const& { return this->Raw; } // NOLINT(google-explicit-constructor)

  operator T() const&& = delete;
 
  explicit operator bool() const { return this->Raw != nullptr; }
 
private:
  T Raw = nullptr;
};
 
template <typename T, typename Traits>
bool operator==(const Handle<T, Traits>& handle, std::nullptr_t)
{
  return handle.Get() == nullptr;
}
template <typename T, typename Traits>
bool operator!=(const Handle<T, Traits>& handle, std::nullptr_t)
{
  return handle.Get() != nullptr;
}
template <typename T, typename Traits>
bool operator==(std::nullptr_t, const Handle<T, Traits>& handle)
{
  return handle.Get() == nullptr;
}
template <typename T, typename Traits>
bool operator!=(std::nullptr_t, const Handle<T, Traits>& handle)
{
  return handle.Get() != nullptr;
}

template <typename T, typename ReleaseFn>
void ReleaseAndNull(T& raw, ReleaseFn release)
{
  if (raw != nullptr)
  {
    release(raw);
    raw = nullptr;
  }
}
 
// The `wgpu*` names redirect to dispatch table entries, whose addresses are not
// constant expressions and so cannot be template arguments.
#define vtkWebGPUDeclareHandle(Name)                                                               \
  struct Name##Traits                                                                              \
  {                                                                                                \
    static void AddRef(WGPU##Name handle)                                                          \
    {                                                                                              \
      wgpu##Name##AddRef(handle);                                                                  \
    }                                                                                              \
    static void Release(WGPU##Name handle)                                                         \
    {                                                                                              \
      wgpu##Name##Release(handle);                                                                 \
    }                                                                                              \
  };                                                                                               \
  using Name = Handle<WGPU##Name, Name##Traits>
 
vtkWebGPUDeclareHandle(Adapter);
vtkWebGPUDeclareHandle(BindGroup);
vtkWebGPUDeclareHandle(BindGroupLayout);
vtkWebGPUDeclareHandle(Buffer);
vtkWebGPUDeclareHandle(CommandBuffer);
vtkWebGPUDeclareHandle(CommandEncoder);
vtkWebGPUDeclareHandle(ComputePassEncoder);
vtkWebGPUDeclareHandle(ComputePipeline);
vtkWebGPUDeclareHandle(Device);
vtkWebGPUDeclareHandle(Instance);
vtkWebGPUDeclareHandle(PipelineLayout);
vtkWebGPUDeclareHandle(QuerySet);
vtkWebGPUDeclareHandle(Queue);
vtkWebGPUDeclareHandle(RenderBundle);
vtkWebGPUDeclareHandle(RenderBundleEncoder);
vtkWebGPUDeclareHandle(RenderPassEncoder);
vtkWebGPUDeclareHandle(RenderPipeline);
vtkWebGPUDeclareHandle(Sampler);
vtkWebGPUDeclareHandle(ShaderModule);
vtkWebGPUDeclareHandle(Surface);
vtkWebGPUDeclareHandle(Texture);
vtkWebGPUDeclareHandle(TextureView);
 
#undef vtkWebGPUDeclareHandle
 
VTK_ABI_NAMESPACE_END
} // namespace vtkWebGPU
 
#endif
// VTK-HeaderTest-Exclude: vtkWebGPUHandle.h