RhiIndirectCompat.hpp

#pragma once
 
#include <QtGui/private/qrhi_p.h>
 
#include <type_traits>
 
namespace score::gfx
{
namespace detail
{
template <typename CB, typename = void>
struct rhi_has_indirect_count : std::false_type
{
};
template <typename CB>
struct rhi_has_indirect_count<
    CB, std::void_t<decltype(std::declval<CB&>().drawIndexedIndirectCount(
            static_cast<QRhiBuffer*>(nullptr), 0u,
            static_cast<QRhiBuffer*>(nullptr), 0u, 0u, 0u))>> : std::true_type
{
};
 
template <typename CB, typename = void>
struct rhi_has_dispatch_indirect : std::false_type
{
};
template <typename CB>
struct rhi_has_dispatch_indirect<
    CB, std::void_t<decltype(std::declval<CB&>().dispatchIndirect(
            static_cast<QRhiBuffer*>(nullptr), 0u))>> : std::true_type
{
};
 
// Feature-enum probes. The enumerators are named through a dependent type so
// the code is well-formed when they do not exist.
template <typename R, typename = void>
struct rhi_feature_indirect_count
{
  static bool supported(R&) noexcept { return false; }
};
template <typename R>
struct rhi_feature_indirect_count<R, std::void_t<decltype(R::DrawIndirectCount)>>
{
  static bool supported(R& rhi) noexcept
  {
    return rhi.isFeatureSupported(R::DrawIndirectCount);
  }
};
 
template <typename R, typename = void>
struct rhi_feature_dispatch_indirect
{
  static bool supported(R&) noexcept { return false; }
};
template <typename R>
struct rhi_feature_dispatch_indirect<R, std::void_t<decltype(R::DispatchIndirect)>>
{
  static bool supported(R& rhi) noexcept
  {
    return rhi.isFeatureSupported(R::DispatchIndirect);
  }
};
}
 
#if defined(SCORE_GFX_SIMULATE_QT612)
inline constexpr bool rhiHasDrawIndirectCount = false;
inline constexpr bool rhiHasDispatchIndirect = false;
#else
inline constexpr bool rhiHasDrawIndirectCount
    = detail::rhi_has_indirect_count<QRhiCommandBuffer>::value;
inline constexpr bool rhiHasDispatchIndirect
    = detail::rhi_has_dispatch_indirect<QRhiCommandBuffer>::value;
#endif
 
template <typename R = QRhi>
inline bool rhiSupportsDrawIndirectCount(R& rhi) noexcept
{
  if constexpr(rhiHasDrawIndirectCount)
    return detail::rhi_feature_indirect_count<R>::supported(rhi);
  else
    return false;
}
 
template <typename R = QRhi>
inline bool rhiSupportsDispatchIndirect(R& rhi) noexcept
{
  if constexpr(rhiHasDispatchIndirect)
    return detail::rhi_feature_dispatch_indirect<R>::supported(rhi);
  else
    return false;
}
 
template <typename CB = QRhiCommandBuffer>
inline bool drawIndirectCountCompat(
    CB& cb, bool indexed, QRhiBuffer* indirectBuffer, quint32 indirectOffset,
    QRhiBuffer* countBuffer, quint32 countOffset, quint32 maxDrawCount,
    quint32 stride) noexcept
{
  if constexpr(rhiHasDrawIndirectCount)
  {
    if(indexed)
      cb.drawIndexedIndirectCount(
          indirectBuffer, indirectOffset, countBuffer, countOffset,
          maxDrawCount, stride);
    else
      cb.drawIndirectCount(
          indirectBuffer, indirectOffset, countBuffer, countOffset,
          maxDrawCount, stride);
    return true;
  }
  else
  {
    (void)cb;
    return false;
  }
}
 
namespace detail
{
template <typename P, typename = void>
struct rhi_pipeline_uses_indirect_draws
{
  static constexpr bool exists = false;
  static typename P::Flags flag() noexcept { return {}; }
};
template <typename P>
struct rhi_pipeline_uses_indirect_draws<P, std::void_t<decltype(P::UsesIndirectDraws)>>
{
  static constexpr bool exists = true;
  static typename P::Flags flag() noexcept { return P::UsesIndirectDraws; }
};
 
template <typename RB, typename = void>
struct rhi_renderbuffer_no_transient_backing
{
  static constexpr bool exists = false;
  static typename RB::Flags flag() noexcept { return {}; }
};
template <typename RB>
struct rhi_renderbuffer_no_transient_backing<
    RB, std::void_t<decltype(RB::NoTransientBacking)>>
{
  static constexpr bool exists = true;
  static typename RB::Flags flag() noexcept { return RB::NoTransientBacking; }
};
}
 
#if defined(SCORE_GFX_SIMULATE_QT612)
inline constexpr bool rhiHasIndirectCommandBufferFlags = false;
#else
inline constexpr bool rhiHasIndirectCommandBufferFlags
    = detail::rhi_pipeline_uses_indirect_draws<QRhiGraphicsPipeline>::exists
      && detail::rhi_renderbuffer_no_transient_backing<QRhiRenderBuffer>::exists;
#endif
 
inline QRhiGraphicsPipeline::Flags indirectDrawPipelineFlags(const QRhi& rhi) noexcept
{
  if constexpr(rhiHasIndirectCommandBufferFlags)
    if(rhi.backend() == QRhi::Metal)
      return detail::rhi_pipeline_uses_indirect_draws<QRhiGraphicsPipeline>::flag();
  return {};
}
 
inline QRhiRenderBuffer::Flags depthStencilRenderBufferFlags(const QRhi& rhi) noexcept
{
  if constexpr(rhiHasIndirectCommandBufferFlags)
    if(rhi.backend() == QRhi::Metal)
      return detail::rhi_renderbuffer_no_transient_backing<QRhiRenderBuffer>::flag();
  return {};
}
 
template <typename CB = QRhiCommandBuffer>
inline bool dispatchIndirectCompat(
    CB& cb, QRhiBuffer* argsBuffer, quint32 argsOffset) noexcept
{
  if constexpr(rhiHasDispatchIndirect)
  {
    cb.dispatchIndirect(argsBuffer, argsOffset);
    return true;
  }
  else
  {
    (void)cb;
    return false;
  }
}
}