IsfBindingsBuilder.hpp

#pragma once
#include <QString>
#include <functional>
 
// 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};        
  bool adopted{false};     
  bool from_port{false};   
  int64_t size{0};         
  int64_t offset{0};
  QString refused;
 
  // 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};
 
  int size_port_index{-1};
  int count{0};
};
 
struct GraphicsStorageImage
{
  std::string name;
  std::string access; 
  std::string format; 
  bool is3D{false};
  bool cubemap{false};    
  bool is_array{false};   
  bool persistent{false}; 
  std::string width_expression;
  std::string height_expression;
  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};      
  bool adopted{false};    
  bool from_port{false};  
  int binding{-1};
  QRhiShaderResourceBinding::StageFlags stages{};
  int input_port_index{-1};
  int64_t offset{0};
  int64_t size{0};
  QString refused; 
 
  int64_t declared_size{};
  int64_t min_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};
 
  SCORE_PLUGIN_GFX_EXPORT void release(RenderList& renderer);
};
 
// --- API ------------------------------------------------------------------
 
SCORE_PLUGIN_GFX_EXPORT
void collectGraphicsStorageResources(
    const isf::descriptor& desc, int firstBinding, GraphicsStorageResources& out,
    int firstInlet = 0, int firstImageBinding = -1);
 
SCORE_PLUGIN_GFX_EXPORT
int graphicsStorageImageBindingCount(const isf::descriptor& desc) noexcept;
 
SCORE_PLUGIN_GFX_EXPORT
std::vector<int> storageImageInputSamplers(
    const isf::descriptor& desc, const std::vector<Port*>& ports, int firstInlet = 0);
 
SCORE_PLUGIN_GFX_EXPORT
void ensureStorageResources(
    QRhi& rhi, QRhiResourceUpdateBatch& res, const RenderList& renderer,
    const isf::descriptor& desc, GraphicsStorageResources& store,
    QSize renderSize,
    const std::function<QSize(const GraphicsStorageImage&, QSize)>& imageSize = {});
 
SCORE_PLUGIN_GFX_EXPORT
bool resizeCountedStorage(
    QRhi& rhi, QRhiResourceUpdateBatch& res, const std::vector<Port*>& inputPorts,
    const isf::descriptor& desc, GraphicsStorageResources& store);
 
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;
 
}