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 <ossia/detail/hash_map.hpp>
#include <ossia/detail/small_flat_map.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <span>
 
namespace score::gfx
{
class Node;
class NodeModel;
struct Port;
struct Edge;
class RenderList;
struct Sampler
{
  QRhiSampler* sampler{};
  QRhiTexture* texture{};
};
 
struct AudioTexture
{
  ossia::hash_map<RenderList*, Sampler> samplers;
 
  std::vector<float> data;
  int channels{};
  int fixedSize{0};
  enum Mode
  {
    Waveform,
    FFT,
    Histogram
  } mode{};
};
 
struct Port
{
  score::gfx::Node* node{};
 
  void* value{};
 
  Types type{};
 
  Flag flags{};
 
  std::vector<Edge*> edges;
};
 
struct Edge
{
  Edge(Port* source, Port* sink, Process::CableType t)
      : source{source}
      , sink{sink}
      , type{t}
  {
    source->edges.push_back(this);
    sink->edges.push_back(this);
  }
 
  ~Edge()
  {
    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{};
};
 
struct Pipeline
{
  QRhiGraphicsPipeline* pipeline{};
  QRhiShaderResourceBindings* srb{};
 
  void release()
  {
    delete pipeline;
    pipeline = nullptr;
 
    delete srb;
    srb = nullptr;
  }
};
 
struct TextureRenderTarget
{
  QRhiTexture* texture{};                              // Primary color attachment (location 0)
  std::vector<QRhiTexture*> additionalColorTextures;   // MRT: locations 1..N
  QRhiRenderBuffer* colorRenderBuffer{};
  QRhiRenderBuffer* depthRenderBuffer{};
  QRhiTexture* depthTexture{};                         // Sampleable depth (alternative to depthRenderBuffer)
  QRhiTexture* msDepthTexture{};                       // MSAA depth attachment when depthTexture is the resolve target
  QRhiRenderPassDescriptor* renderPass{};
  QRhiRenderTarget* renderTarget{};
 
  operator bool() const noexcept { return texture != nullptr; }
 
  int colorAttachmentCount() const noexcept
  {
    return texture ? 1 + (int)additionalColorTextures.size() : 0;
  }
 
  // Returns the actual MSAA sample count of this render target, or -1 if it
  // cannot be determined from the stored fields (e.g. when only renderPass is
  // set, as for placeholders that target a swap chain). Callers must treat
  // -1 as "unknown — fall back to the renderlist's global sample count".
  // This value is the authoritative input to QRhiGraphicsPipeline::setSampleCount()
  // when known, since an RT may have been degraded (samplable-depth + MSAA
  // without depth-resolve support).
  int sampleCount() const noexcept
  {
    if(renderTarget)
      return renderTarget->sampleCount();
    if(colorRenderBuffer)
      return colorRenderBuffer->sampleCount();
    if(texture)
      return texture->sampleCount();
    return -1;
  }
 
  void release()
  {
    if(texture)
    {
      delete texture;
      texture = nullptr;
 
      for(auto* t : additionalColorTextures)
        delete t;
      additionalColorTextures.clear();
 
      delete colorRenderBuffer;
      colorRenderBuffer = nullptr;
 
      delete depthRenderBuffer;
      depthRenderBuffer = nullptr;
 
      delete depthTexture;
      depthTexture = nullptr;
 
      delete msDepthTexture;
      msDepthTexture = nullptr;
 
      delete renderPass;
      renderPass = nullptr;
 
      delete renderTarget;
      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
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 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 = {});
 
SCORE_PLUGIN_GFX_EXPORT
bool remapPipelineVertexInputs(
    QRhiGraphicsPipeline& pip, const QShader& vertexShader,
    const ossia::geometry& geom);
 
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
std::pair<QShader, QShader>
makeShaders(const RenderState& v, QString vert, QString frag);
 
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
std::vector<Sampler> initInputSamplers(
    const score::gfx::Node& node, RenderList& renderer, const std::vector<Port*>& ports);
}