score-plugin-gfx/Gfx/Graph/Utils.hpp

#pragma once
#include <Process/Dataflow/CableData.hpp>
 
#include <Gfx/Graph/Mesh.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Gfx/Graph/Scale.hpp>
#include <Gfx/Graph/Uniforms.hpp>
#include <Gfx/Graph/VertexFallbackPlan.hpp>
 
#include <ossia/detail/hash_map.hpp>
#include <ossia/detail/small_flat_map.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <QtCore/QDebug>
 
#include <atomic>
#include <span>
 
namespace isf
{
struct descriptor;
}
 
namespace score::gfx
{
class Node;
class NodeModel;
struct Port;
struct RenderTargetSpecs;
class VertexFallbackPool;
struct Edge;
class RenderList;
 
struct OffscreenFrame
{
  explicit OffscreenFrame(QRhi& rhi) noexcept
  {
    QRhiCommandBuffer* cb{};
    m_beginResult = simulateDeviceLost.load(std::memory_order_relaxed)
                        ? QRhi::FrameOpDeviceLost
                        : rhi.beginOffscreenFrame(&cb);
    if(m_beginResult == QRhi::FrameOpSuccess)
    {
      if(cb)
      {
        m_rhi = &rhi;
        m_commands = cb;
      }
      else
      {
        thread_local int nested = 0;
        if((nested++ % 600) == 0)
          qWarning() << "score.gfx: beginOffscreenFrame entered while a frame is "
                        "already recording; skipping this render (occurrence"
                     << nested << ")";
      }
    }
  }
 
  ~OffscreenFrame() noexcept { end(); }
 
  OffscreenFrame(const OffscreenFrame&) = delete;
  OffscreenFrame(OffscreenFrame&&) = delete;
  OffscreenFrame& operator=(const OffscreenFrame&) = delete;
  OffscreenFrame& operator=(OffscreenFrame&&) = delete;
 
  explicit operator bool() const noexcept { return m_commands; }
  QRhiCommandBuffer& commands() const noexcept { return *m_commands; }
 
  QRhi::FrameOpResult beginResult() const noexcept { return m_beginResult; }
  QRhi::FrameOpResult endResult() const noexcept { return m_endResult; }
  bool deviceLost() const noexcept
  {
    return m_beginResult == QRhi::FrameOpDeviceLost
           || m_endResult == QRhi::FrameOpDeviceLost;
  }
 
  QRhi::FrameOpResult end() noexcept
  {
    if(auto* rhi = m_rhi)
    {
      m_rhi = nullptr;
      m_commands = nullptr;
      m_endResult = rhi->endOffscreenFrame();
    }
    return m_endResult;
  }
 
  static inline std::atomic_bool simulateDeviceLost{false};
 
private:
  QRhi* m_rhi{};
  QRhiCommandBuffer* m_commands{};
  QRhi::FrameOpResult m_beginResult{QRhi::FrameOpSuccess};
  QRhi::FrameOpResult m_endResult{QRhi::FrameOpSuccess};
};
 
struct SwapChainFrameGuard
{
  SwapChainFrameGuard(QRhi& rhi, QRhiSwapChain& swapChain) noexcept
      : rhi{&rhi}
      , swapChain{&swapChain}
  {
  }
 
  ~SwapChainFrameGuard() noexcept
  {
    if(rhi && rhi->isRecordingFrame())
      rhi->endFrame(swapChain, QRhi::SkipPresent);
  }
 
  SwapChainFrameGuard(const SwapChainFrameGuard&) = delete;
  SwapChainFrameGuard(SwapChainFrameGuard&&) = delete;
  SwapChainFrameGuard& operator=(const SwapChainFrameGuard&) = delete;
  SwapChainFrameGuard& operator=(SwapChainFrameGuard&&) = delete;
 
  void release() noexcept { rhi = nullptr; }
 
private:
  QRhi* rhi{};
  QRhiSwapChain* swapChain{};
};
 
 
struct Sampler
{
  QRhiSampler* sampler{};
  QRhiTexture* texture{};
  QRhiTexture* fallback{};
};
 
struct AudioTexture
{
  ossia::hash_map<RenderList*, Sampler> samplers;
 
  std::vector<float> data;
  int channels{};
  int fixedSize{0};
  enum Mode
  {
    Waveform,
    FFT,
    Histogram
  } mode{};
 
  // Optional sampler config. Empty strings keep legacy defaults
  // (linear / clamp_to_edge). Populated by ISFNode from the parsed
  // audio_input::sampler (FILTER / WRAP). Useful for FFT reads where
  // NEAREST filtering avoids smearing adjacent bins.
  std::string filter;
  std::string wrap;
};
 
struct Port
{
  score::gfx::Node* node{};
 
  void* value{};
 
  Types type{};
 
  Flag flags{};
 
  std::vector<Edge*> edges;
};
 
struct SCORE_PLUGIN_GFX_EXPORT Edge
{
  Edge(Port* source, Port* sink, Process::CableType t);
 
  ~Edge()
  {
    generation.fetch_add(1, std::memory_order_relaxed);
    if(auto it = std::find(source->edges.begin(), source->edges.end(), this);
       it != source->edges.end())
      source->edges.erase(it);
    if(auto it = std::find(sink->edges.begin(), sink->edges.end(), this);
       it != sink->edges.end())
      sink->edges.erase(it);
  }
 
  Port* source{};
  Port* sink{};
  Process::CableType type{};
 
  static inline std::atomic<uint64_t> generation{0};
};
 
inline bool outputGrabbedBySink(const Port& output) noexcept
{
  for(const Edge* e : output.edges)
    if(e && e->sink && (e->sink->flags & Flag::GrabsFromSource) == Flag::GrabsFromSource)
      return true;
  return false;
}
 
struct Pipeline
{
  QRhiGraphicsPipeline* pipeline{};
  QRhiShaderResourceBindings* srb{};
 
  FallbackBindingPlan plan{};
 
  void release()
  {
    if(pipeline)
      pipeline->deleteLater();
    pipeline = nullptr;
 
    if(srb)
      srb->deleteLater();
    srb = nullptr;
 
    plan.clear();
  }
};
 
struct TextureRenderTarget
{
  // The first five members must keep this order: out-of-tree addons
  // aggregate-initialize {texture, colorRenderBuffer, depthRenderBuffer,
  // renderPass, renderTarget}.
  QRhiTexture* texture{};                              // Primary color attachment (location 0)
  QRhiRenderBuffer* colorRenderBuffer{};
  QRhiRenderBuffer* depthRenderBuffer{};
  QRhiRenderPassDescriptor* renderPass{};
  QRhiRenderTarget* renderTarget{};
 
  std::vector<QRhiTexture*> additionalColorTextures;   // MRT: locations 1..N
  std::vector<QRhiRenderBuffer*> additionalColorRenderBuffers; // MRT: MSAA attachments for locations 1..N
  QRhiTexture* depthTexture{};                         // Sampleable depth (alternative to depthRenderBuffer)
  QRhiTexture* msDepthTexture{};                       // MSAA depth attachment when depthTexture is the resolve target
 
  // A 1×1 color texture allocated when the backend requires a color attachment
  // but the user only wants depth-only rendering. Owned by this RT.
  QRhiTexture* dummyColorTexture{};
 
  // Number of array layers on `texture` (1 = non-layered, >1 = texture array).
  int arrayLayers{1};
 
  // Multiview view count (0/1 = disabled).
  int multiViewCount{0};
 
  // Which layer of `texture`/`additionalColorTextures` this RT renders to.
  // -1 = not applicable (non-layered, or MultiView handles it automatically).
  int renderLayer{-1};
 
  operator bool() const noexcept { return texture != nullptr || dummyColorTexture != nullptr || depthTexture != nullptr; }
 
  int colorAttachmentCount() const noexcept
  {
    if(texture)
      return 1 + (int)additionalColorTextures.size();
    if(dummyColorTexture)
      return 1;
    return 0;
  }
 
  // Returns the actual MSAA sample count of this render target, or -1 if it
  // cannot be determined from the stored fields. Callers must treat -1 as
  // "unknown — fall back to the renderlist's global sample count".
  //
  // Lookup priority:
  //   1. colorRenderBuffer (owned MSAA attachment — always authoritative).
  //   2. texture (single-sample resolve target OR non-MSAA render target).
  //   3. depthTexture (depth-only RTs).
  //   4. msDepthTexture (MSAA depth attachment when depth resolve is used).
  //   5. renderTarget — BUT only when this RT genuinely owns its attachments
  //      (colorRenderBuffer/texture/depthTexture set). A "bare" RT that only
  //      carries renderTarget + renderPass (e.g. a swap-chain wrapper
  //      returned by QRhiSwapChain::currentFrameRenderTarget()) is NOT
  //      queried because swap-chain render-target objects lazily write
  //      their sampleCount only when createOrResize() runs — any read before
  //      that returns the default 1, which would silently mismatch a
  //      multi-sample renderPassDescriptor and produce
  //      VUID-VkGraphicsPipelineCreateInfo-multisampledRenderToSingleSampled-06853.
  //   6. Otherwise return -1 so the caller uses RenderList::samples(), which
  //      IS authoritative for externally-managed swap-chain RTs (it drove
  //      the swap-chain sample count in the first place).
  int sampleCount() const noexcept
  {
    if(colorRenderBuffer)
      return colorRenderBuffer->sampleCount();
    if(texture)
      return texture->sampleCount();
    if(msDepthTexture)
      return msDepthTexture->sampleCount();
    if(depthTexture)
      return depthTexture->sampleCount();
    // renderTarget alone without any owned attachment = swap-chain wrapper.
    // Its sampleCount is unreliable pre-createOrResize; fall through.
    return -1;
  }
 
  void release()
  {
    if(texture || dummyColorTexture || depthTexture)
    {
      // Use deleteLater() for all GPU resources: Qt RHI commands are async
      // and resources may still be referenced by in-flight frames until
      // endFrame() completes. deleteLater() defers actual destruction to
      // the next beginFrame().
      if(texture)
        texture->deleteLater();
      texture = nullptr;
 
      if(dummyColorTexture)
        dummyColorTexture->deleteLater();
      dummyColorTexture = nullptr;
 
      for(auto* t : additionalColorTextures)
        t->deleteLater();
      additionalColorTextures.clear();
 
      if(colorRenderBuffer)
        colorRenderBuffer->deleteLater();
      colorRenderBuffer = nullptr;
 
      for(auto* rb : additionalColorRenderBuffers)
        rb->deleteLater();
      additionalColorRenderBuffers.clear();
 
      if(depthRenderBuffer)
        depthRenderBuffer->deleteLater();
      depthRenderBuffer = nullptr;
 
      if(depthTexture)
        depthTexture->deleteLater();
      depthTexture = nullptr;
 
      if(msDepthTexture)
        msDepthTexture->deleteLater();
      msDepthTexture = nullptr;
 
      if(renderPass)
        renderPass->deleteLater();
      renderPass = nullptr;
 
      if(renderTarget)
        renderTarget->deleteLater();
      renderTarget = nullptr;
    }
  }
};
 
struct Image
{
  QString path;
  std::vector<QImage> frames;
};
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget
createRenderTarget(const RenderState& state, QRhiTexture* tex, int samples, bool depth, bool samplableDepth = false);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createRenderTarget(
    const RenderState& state, QRhiTexture::Format fmt, QSize sz, int samples, bool depth,
    bool samplableDepth = false, QRhiTexture::Flags flags = {});
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createRenderTarget(
    const RenderState& state,
    std::span<QRhiTexture* const> colorTextures,
    QRhiTexture* depthTexture,
    int samples);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createDepthOnlyRenderTarget(
    const RenderState& state, QSize sz, int samples, bool samplableDepth = true,
    QRhiTexture::Format depthFmt = QRhiTexture::D32F);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createDepthOnlyRenderTarget(
    const RenderState& state, QRhiTexture* externalDepthTexture, int samples,
    bool samplableDepth = true);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createLayeredRenderTarget(
    const RenderState& state, QRhiTexture* colorTextureArray, int renderLayer,
    QRhiTexture* depthTexture, int samples);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createLayeredRenderTarget(
    const RenderState& state, std::span<QRhiTexture* const> colorTextures,
    int renderLayer, QRhiTexture* depthTexture, int samples);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createMultiViewRenderTarget(
    const RenderState& state, QRhiTexture* colorTextureArray, int multiViewCount,
    QRhiTexture* depthTextureArray, int samples);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createMultiViewRenderTarget(
    const RenderState& state, std::span<QRhiTexture* const> colorTextures,
    int multiViewCount, QRhiTexture* depthTextureArray, int samples);
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture::Format parseOutputFormat(
    const std::string& fmt, QRhiTexture::Format fallback) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
void replaceBuffer(QRhiShaderResourceBindings&, int binding, QRhiBuffer* newBuffer);
SCORE_PLUGIN_GFX_EXPORT
void replaceSampler(QRhiShaderResourceBindings&, int binding, QRhiSampler* newSampler);
SCORE_PLUGIN_GFX_EXPORT
void replaceTexture(QRhiShaderResourceBindings&, int binding, QRhiTexture* newTexture);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceBuffer(
    std::vector<QRhiShaderResourceBinding>&, int binding, QRhiBuffer* newBuffer);
SCORE_PLUGIN_GFX_EXPORT
void replaceSampler(
    std::vector<QRhiShaderResourceBinding>&, int binding, QRhiSampler* newSampler);
SCORE_PLUGIN_GFX_EXPORT
void replaceTexture(
    std::vector<QRhiShaderResourceBinding>&, int binding, QRhiTexture* newTexture);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceTextureElement(
    std::vector<QRhiShaderResourceBinding>&, int binding, int element,
    QRhiTexture* newTexture);
SCORE_PLUGIN_GFX_EXPORT
void replaceTextureElement(
    QRhiShaderResourceBindings&, int binding, int element, QRhiTexture* newTexture);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceSampler(
    QRhiShaderResourceBindings&, QRhiSampler* oldSampler, QRhiSampler* newSampler);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceTexture(
    QRhiShaderResourceBindings&, QRhiSampler* sampler, QRhiTexture* newTexture);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceSamplerAndTexture(
    QRhiShaderResourceBindings&, QRhiSampler* oldSampler, QRhiSampler* newSampler,
    QRhiTexture* newTexture);
 
SCORE_PLUGIN_GFX_EXPORT
void replaceTexture(
    QRhiShaderResourceBindings& srb, QRhiTexture* old_tex, QRhiTexture* new_tex);
SCORE_PLUGIN_GFX_EXPORT
QRhiShaderResourceBindings* createDefaultBindings(
    const RenderList& renderer, const TextureRenderTarget& rt, QRhiBuffer* processUBO,
    QRhiBuffer* materialUBO, std::span<const Sampler> samplers,
    std::span<QRhiShaderResourceBinding> additionalBindings = {},
    int firstSamplerBinding = 3);
 
SCORE_PLUGIN_GFX_EXPORT
const ossia::geometry::attribute* findGeometryAttribute(
    const ossia::geometry& geom, std::string_view name, std::string_view semantic_key);
 
inline QRhiBuffer::Type bufferTypeFor(
    QRhiBuffer::UsageFlags usage,
    QRhiBuffer::Type nonDynamic = QRhiBuffer::Immutable) noexcept
{
  return usage.testFlag(QRhiBuffer::UniformBuffer) ? QRhiBuffer::Dynamic
                                                   : nonDynamic;
}
 
SCORE_PLUGIN_GFX_EXPORT
bool remapPipelineVertexInputs(
    QRhiGraphicsPipeline& pip, const QShader& vertexShader,
    const ossia::geometry& geom, FallbackBindingPlan* outPlan = nullptr,
    QRhi* rhi = nullptr);
 
// FallbackBindingPlan lives in its own header so both Utils.hpp and
// CustomMesh.hpp can depend on it without creating an include cycle
// (Utils.hpp depends on Mesh.hpp, which transitively reaches CustomMesh
// consumers). See <Gfx/Graph/VertexFallbackPlan.hpp>.
 
SCORE_PLUGIN_GFX_EXPORT
bool remapPipelineVertexInputs(
    QRhiGraphicsPipeline& pip, const QShader& vertexShader,
    const ossia::geometry& geom, const isf::descriptor& desc,
    QRhi& rhi, VertexFallbackPool& pool, QRhiResourceUpdateBatch& batch,
    FallbackBindingPlan& outPlan);
 
SCORE_PLUGIN_GFX_EXPORT void dropTrailingOrphanVertexBindings(
    QRhiVertexInputLayout& layout) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT void warnOrphanVertexBindings(
    const QRhiVertexInputLayout& layout, const char* where) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
Pipeline buildPipeline(
    const RenderList& renderer, const Mesh& mesh, const QShader& vertexS,
    const QShader& fragmentS, const TextureRenderTarget& rt, QRhiBuffer* processUBO,
    QRhiBuffer* materialUBO, std::span<const Sampler> samplers,
    std::span<QRhiShaderResourceBinding> additionalBindings = {});
 
SCORE_PLUGIN_GFX_EXPORT
Pipeline buildPipeline(
    const RenderList& renderer, const Mesh& mesh, const QShader& vertexS,
    const QShader& fragmentS, const TextureRenderTarget& rt,
    QRhiShaderResourceBindings* srb);
 
SCORE_PLUGIN_GFX_EXPORT
Pipeline buildPipeline(
    const RenderList& renderer, const Mesh& mesh, const QShader& vertexS,
    const QShader& fragmentS, const TextureRenderTarget& rt,
    QRhiShaderResourceBindings* srb, const QRhiGraphicsPipeline::TargetBlend& blend);
 
SCORE_PLUGIN_GFX_EXPORT
Pipeline buildPipeline(
    const RenderList& renderer, const Mesh& mesh, const QShader& vertexS,
    const QShader& fragmentS, const TextureRenderTarget& rt, QRhiBuffer* processUBO,
    QRhiBuffer* materialUBO, std::span<const Sampler> samplers,
    const QRhiGraphicsPipeline::TargetBlend& blend,
    std::span<QRhiShaderResourceBinding> additionalBindings = {});
 
// Forward declarations — definitions in PipelineStateHelpers.hpp, IsfBindingsBuilder.hpp
} // namespace score::gfx
 
namespace isf
{
struct sampler_config;
}
 
namespace score::gfx
{
SCORE_PLUGIN_GFX_EXPORT
QRhiSampler* makeSampler(QRhi& rhi, const isf::sampler_config& cfg);
 
SCORE_PLUGIN_GFX_EXPORT
bool declaresCompare(const isf::sampler_config& cfg) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
bool followTextureMips(QRhiSampler& sampler, const QRhiTexture& texture);
} // namespace score::gfx
 
namespace isf
{
struct pipeline_state;
}
 
namespace score::gfx
{
struct GraphicsStorageResources;
 
SCORE_PLUGIN_GFX_EXPORT
Pipeline buildPipelineWithState(
    const RenderList& renderer, const Mesh& mesh, const QShader& vertexS,
    const QShader& fragmentS, const TextureRenderTarget& rt, QRhiBuffer* processUBO,
    QRhiBuffer* materialUBO, std::span<const Sampler> samplers,
    std::span<QRhiShaderResourceBinding> extraBindings,
    const isf::pipeline_state& state,
    int multiViewCount = 0,
    bool useShadingRate = false,
    int firstSamplerBinding = 3,
    std::span<const QRhiGraphicsPipeline::TargetBlend> seedBlends = {});
 
SCORE_PLUGIN_GFX_EXPORT
std::pair<QShader, QShader> makeShaders(
    const RenderState& v, QString vert, QString frag, int multiViewCount = 0);
 
SCORE_PLUGIN_GFX_EXPORT
QShader makeCompute(const RenderState& v, QString compt);
 
struct SCORE_PLUGIN_GFX_EXPORT DefaultShaderMaterial
{
  void init(
      RenderList& renderer, const std::vector<Port*>& input,
      ossia::small_vector<Sampler, 8>& samplers);
 
  QRhiBuffer* buffer{};
  int size{};
};
 
SCORE_PLUGIN_GFX_EXPORT
QSize resizeTextureSize(QSize img, int min, int max) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
QImage resizeTexture(const QImage& img, int min, int max) noexcept;
 
inline void copyMatrix(const QMatrix4x4& mat, float* ptr) noexcept
{
  memcpy(ptr, mat.constData(), sizeof(float) * 16);
}
inline void copyMatrix(const QMatrix3x3& mat, float* ptr) noexcept
{
  memcpy(ptr, mat.constData(), sizeof(float) * 9);
}
 
SCORE_PLUGIN_GFX_EXPORT
QSizeF computeScaleForMeshSizing(score::gfx::ScaleMode mode, QSizeF viewport, QSizeF texture);
 
SCORE_PLUGIN_GFX_EXPORT
QSizeF computeScaleForTexcoordSizing(
    score::gfx::ScaleMode mode, QSizeF viewport, QSizeF texture);
 
inline void updateDynamicBufferWithStoredData(
    QRhiResourceUpdateBatch* ub
  , QRhiBuffer* buf
  , int offset
  , int64_t bytesize
  , const char* data
  )
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
  ub->updateDynamicBuffer(buf, offset, QByteArray::fromRawData(data, bytesize));
#else
  ub->updateDynamicBuffer(buf, offset, bytesize, data);
#endif
}
 
inline void updateDynamicBufferWithStoredData(
    QRhiResourceUpdateBatch* ub
    , QRhiBuffer* buf
    , int offset
    , QByteArray b
    )
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
  ub->updateDynamicBuffer(buf, offset, std::move(b));
#else
  ub->updateDynamicBuffer(buf, offset, b.size(), b.data());
#endif
}
 
inline void uploadStaticBufferWithStoredData(
    QRhiResourceUpdateBatch* ub
    , QRhiBuffer* buf
    , int offset
    , int64_t bytesize
    , const char* data
    )
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
  ub->uploadStaticBuffer(buf, offset, QByteArray::fromRawData(data, bytesize));
#else
  ub->uploadStaticBuffer(buf, offset, bytesize, data);
#endif
}
 
inline void uploadStaticBufferWithStoredData(
    QRhiResourceUpdateBatch* ub
    , QRhiBuffer* buf
    , int offset
    , QByteArray b
    )
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
  ub->uploadStaticBuffer(buf, offset, std::move(b));
#else
  ub->uploadStaticBuffer(buf, offset, b.size(), b.data());
#endif
}
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture::Format imageFormatFromQualifier(std::string_view qualifier) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture* createStorageImagePlaceholder(
    QRhi& rhi, QRhiResourceUpdateBatch& res, std::string_view qualifier, int dimensions,
    bool array, bool cube);
 
SCORE_PLUGIN_GFX_EXPORT
int storageImageUnitLimit(QRhi& rhi);
 
SCORE_PLUGIN_GFX_EXPORT
int maxStorageImageBinding(QStringView glsl);
 
SCORE_PLUGIN_GFX_EXPORT
bool warnStorageImageUnits(
    QRhi& rhi, const char* kind, std::initializer_list<const QString*> sources);
 
SCORE_PLUGIN_GFX_EXPORT
std::vector<Sampler> initInputSamplers(
    const score::gfx::Node& node, RenderList& renderer, const std::vector<Port*>& ports,
    const isf::descriptor* desc = nullptr);
 
SCORE_PLUGIN_GFX_EXPORT
void updateInputSamplerFilter(
    std::span<const Sampler> samplers, const score::gfx::Node& node, const Port& input,
    const RenderTargetSpecs& spec);
}