GpuCapabilities.hpp

Go to the documentation of this file.

#pragma once
 
#include <score_plugin_gfx_export.h>
 
#include <cstdint>
 
class QRhi;
 
namespace score::gfx::interop
{
 
enum class GpuVendor : uint8_t
{
  Unknown = 0,
  NvidiaConsumer,   
  NvidiaProQuadro,  
  Amd,              
  Apple,            
  Intel,            
  Other,
};
 
enum class HostOs : uint8_t
{
  Linux = 0,
  Windows,
  MacOS,
  Other,
};
 
enum class QRhiBackendKind : uint8_t
{
  Unknown = 0,
  OpenGL,
  Vulkan,
  D3D11,
  D3D12,
  Metal,
  Null,
};
 
struct AmdGlExtensions
{
  bool busAddressable{};         
  bool externalVirtualMemory{};  
  bool externalPhysicalMemory{}; 
  bool pinnedMemory{};           
  constexpr bool any() const noexcept
  {
    return busAddressable || externalVirtualMemory || externalPhysicalMemory
           || pinnedMemory;
  }
};
 
struct SCORE_PLUGIN_GFX_EXPORT GpuCapabilities
{
  // -- Identity --------------------------------------------------------
  GpuVendor vendor{GpuVendor::Unknown};
  HostOs os{HostOs::Other};
  QRhiBackendKind backend{QRhiBackendKind::Unknown};
 
  char rendererName[128]{};
 
  char driverVersion[64]{};
 
  // -- NVIDIA DVP ------------------------------------------------------
 
  bool dvpLoaded{};
  bool dvpHaveGl{};
  bool dvpHaveD3D11{};
  bool dvpHaveCuda{};
 
  // -- CUDA driver API ------------------------------------------------
 
  bool cudaLoaded{};
  bool cudaVmmSupported{};
  bool nvidiaPeermem{};
 
  // -- AMD GL ----------------------------------------------------------
 
  AmdGlExtensions amd{};
 
  // -- Vulkan ----------------------------------------------------------
 
  bool vkExternalMemorySupported{};
 
  // -- Apple -----------------------------------------------------------
 
  bool metalSupported{};
 
  // -- Convenience capability helpers ----------------------------------
 
  constexpr bool hasTier0() const noexcept
  {
    return (cudaVmmSupported && nvidiaPeermem) || amd.busAddressable;
  }
 
  constexpr bool hasTier1Dvp() const noexcept
  {
    return dvpLoaded && (dvpHaveGl || dvpHaveD3D11 || dvpHaveCuda);
  }
 
  constexpr bool rulesOutNvidiaPaths() const noexcept
  {
    return vendor == GpuVendor::Amd || vendor == GpuVendor::Intel
           || vendor == GpuVendor::Apple;
  }
 
  constexpr bool hasTier2AmdPinned() const noexcept
  {
    return amd.externalVirtualMemory || amd.externalPhysicalMemory
           || amd.pinnedMemory;
  }
};
 
SCORE_PLUGIN_GFX_EXPORT
GpuCapabilities probeContextFree();
 
SCORE_PLUGIN_GFX_EXPORT
void probeFromQRhi(GpuCapabilities& caps, QRhi* rhi) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
void probeGlExtensions(GpuCapabilities& caps) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
void probeGlExtensions(GpuCapabilities& caps, QRhi* rhi) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
const char* gpuVendorName(GpuVendor v) noexcept;
SCORE_PLUGIN_GFX_EXPORT
const char* qrhiBackendName(QRhiBackendKind b) noexcept;
 
} // namespace score::gfx::interop