IsfBindingsBuilder.hpp

#pragma once
 
// Shared infrastructure for binding `storage_input` and `csf_image_input`
// declarations into a graphics pipeline's shader resource bindings.
//
// Mirrors the pattern established by RenderedCSFNode (for compute) but wired
// to Vertex|Fragment stages for ISF / Raw Raster Pipeline / Scene Pass nodes.
 
#include <Gfx/Graph/Utils.hpp>
#include <isf.hpp>
 
#include <QtGui/private/qrhi_p.h>
 
#include <score_plugin_gfx_export.h>
 
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
namespace score::gfx
{
 
struct GraphicsSSBO
{
  std::string name;        
  std::string access;      
  std::string buffer_usage;
  bool persistent{false};  
  bool owned{true};        
  int64_t size{0};         
 
  // Layout fields (for size computation + validation). May be empty for auxiliaries.
  std::vector<isf::storage_input::layout_field> layout;
 
  // Buffer handles. `buffer` is the currently-written slot (R/W for persistent).
  // `prev` is only set when persistent — holds the previous frame's data (R/O).
  QRhiBuffer* buffer{};
  QRhiBuffer* prev{};
 
  // Resolved SRB binding slots.
  int binding{-1};       
  int prev_binding{-1};  
 
  // Stages that see this binding (fragment / vertex / both).
  QRhiShaderResourceBinding::StageFlags stages{};
 
  // Optional: indices into the Node's input/output port vectors. -1 = not
  // connected to a port (e.g. private aux buffer or persistent-only).
  int input_port_index{-1};
  int output_port_index{-1};
};
 
struct GraphicsStorageImage
{
  std::string name;
  std::string access; 
  std::string format; 
  bool is3D{false};
  bool cubemap{false};    
  bool is_array{false};   
  bool persistent{false}; 
  int depth{0};   
  int layers{0}; 
 
  QRhiTexture* texture{}; 
  QRhiTexture* prev{};    
  bool owned{true};
 
  int binding{-1};
  int prev_binding{-1};   
  QRhiShaderResourceBinding::StageFlags stages{};
 
  int input_port_index{-1};
  int output_port_index{-1};
};
 
struct GraphicsUBO
{
  std::string name;
  QRhiBuffer* buffer{};
  bool owned{false};      
  int binding{-1};
  QRhiShaderResourceBinding::StageFlags stages{};
  int input_port_index{-1};
 
  int64_t declared_size{};
};
 
struct GraphicsStorageResources
{
  std::vector<GraphicsSSBO> ssbos;
  std::vector<GraphicsStorageImage> images;
  std::vector<GraphicsUBO> ubos;
 
  // Quick aliases: first SSBO with BUFFER_USAGE="indirect_draw*". Populated
  // by collectGraphicsStorageResources. Updated by callers when the underlying
  // SSBO's buffer pointer changes (e.g. when an upstream CSF rebuilds it).
  QRhiBuffer* indirectDrawBuffer{};
  bool indirectDrawIndexed{false};
  int indirectDrawSsboIndex{-1};
 
  // Next free binding index after all graphics-visible storage resources
  // (SSBOs + images + UBOs) have been assigned by
  // collectGraphicsStorageResources. This is exactly the value libisf's
  // isf_emit_graphics_storage() returns (isf.cpp:3406-3449) and the binding
  // at which the codegen places the multiview UBO (isf.cpp:3773-3783). Callers
  // that append a multiview UBO MUST use this rather than re-deriving a max
  // over ssbos/images alone: that omits uniform_input UBOs and collides the
  // multiview binding with the last UBO's slot. -1 until the first
  // collectGraphicsStorageResources() call.
  int nextBinding{-1};
 
  // Sentinel zero-buffer bound when an SSBO/UBO upstream port disconnects
  // mid-session. QRhi (especially Vulkan) requires every SRB binding to
  // point at a valid resource — without a sentinel, a disconnect leaves
  // the binding pointing at a dangling QRhiBuffer* (the prior upstream's
  // buffer, which was deleteLater'd when the upstream node was destroyed).
  // Lazily allocated on first disconnect, sized to the largest binding
  // observed (sentinelSize). Single buffer reused for both SSBO and UBO
  // disconnects since the descriptor type is set on the SRB binding side,
  // not the buffer side; QRhi accepts a buffer with both StorageBuffer and
  // UniformBuffer usage flags. owned=true; freed in release().
  QRhiBuffer* sentinelBuffer{};        
  QRhiBuffer* sentinelUniformBuffer{}; 
  uint32_t sentinelSize{0};
 
  void release()
  {
    for(auto& s : ssbos)
    {
      if(s.owned)
      {
        if(s.buffer) s.buffer->deleteLater();
        if(s.prev)   s.prev->deleteLater();
      }
      s.buffer = nullptr;
      s.prev = nullptr;
    }
    ssbos.clear();
 
    for(auto& i : images)
    {
      if(i.owned)
      {
        if(i.texture) i.texture->deleteLater();
        if(i.prev) i.prev->deleteLater();
      }
      i.texture = nullptr;
      i.prev = nullptr;
    }
    images.clear();
 
    for(auto& u : ubos)
    {
      if(u.owned && u.buffer)
        u.buffer->deleteLater();
      u.buffer = nullptr;
    }
    ubos.clear();
 
    if(sentinelBuffer)
    {
      sentinelBuffer->deleteLater();
      sentinelBuffer = nullptr;
    }
    if(sentinelUniformBuffer)
    {
      sentinelUniformBuffer->deleteLater();
      sentinelUniformBuffer = nullptr;
    }
    sentinelSize = 0;
 
    indirectDrawBuffer = nullptr;
    indirectDrawSsboIndex = -1;
    nextBinding = -1;
  }
};
 
// --- API ------------------------------------------------------------------
 
SCORE_PLUGIN_GFX_EXPORT
void collectGraphicsStorageResources(
    const isf::descriptor& desc, int firstBinding, GraphicsStorageResources& out);
 
SCORE_PLUGIN_GFX_EXPORT
void ensureStorageResources(
    QRhi& rhi, QRhiResourceUpdateBatch& res, const RenderList& renderer,
    const isf::descriptor& desc, GraphicsStorageResources& store,
    QSize renderSize);
 
SCORE_PLUGIN_GFX_EXPORT
QVarLengthArray<QRhiShaderResourceBinding, 8> buildExtraBindings(
    const GraphicsStorageResources& store);
 
SCORE_PLUGIN_GFX_EXPORT
void bindUpstreamBuffers(
    RenderList& renderer, const std::vector<Port*>& inputPorts,
    GraphicsStorageResources& store,
    QRhiShaderResourceBindings* srb = nullptr);
 
SCORE_PLUGIN_GFX_EXPORT
void swapPersistentSSBOs(
    GraphicsStorageResources& store, QRhiShaderResourceBindings& srb);
 
SCORE_PLUGIN_GFX_EXPORT
void swapPersistentSSBOsState(GraphicsStorageResources& store);
 
SCORE_PLUGIN_GFX_EXPORT
void reapplyStorageBindings(
    const GraphicsStorageResources& store, QRhiShaderResourceBindings& srb);
 
SCORE_PLUGIN_GFX_EXPORT
void bindUpstreamImagesFromGeometry(
    GraphicsStorageResources& store, const ossia::geometry& geometry,
    QRhiShaderResourceBindings* srb = nullptr);
 
SCORE_PLUGIN_GFX_EXPORT
void bindUpstreamBuffersFromGeometry(
    QRhi& rhi, QRhiResourceUpdateBatch& res,
    GraphicsStorageResources& store, const ossia::geometry& geometry,
    QRhiShaderResourceBindings* srb = nullptr);
 
SCORE_PLUGIN_GFX_EXPORT
QRhiShaderResourceBinding::StageFlags visibilityToStages(std::string_view visibility) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
int64_t glslTypeSizeBytes(std::string_view type) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
int64_t glslTypeSizeBytes(std::string_view type, const isf::descriptor& d) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
int64_t std430LayoutSize(
    const std::vector<isf::storage_input::layout_field>& layout) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
int64_t std430ArrayStride(std::string_view type) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
int64_t std430ArrayStride(std::string_view type, const isf::descriptor& d) noexcept;
 
}