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

#pragma once
 
#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 <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{};
 
  std::vector<Edge*> edges;
};
 
struct Edge
{
  Edge(Port* source, Port* sink)
      : source{source}
      , sink{sink}
  {
    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{};
};
 
struct Pipeline
{
  QRhiGraphicsPipeline* pipeline{};
  QRhiShaderResourceBindings* srb{};
 
  void release()
  {
    delete pipeline;
    pipeline = nullptr;
 
    delete srb;
    srb = nullptr;
  }
};
 
struct TextureRenderTarget
{
  QRhiTexture* texture{};
  QRhiRenderBuffer* colorRenderBuffer{};
  QRhiRenderBuffer* depthRenderBuffer{};
  QRhiRenderPassDescriptor* renderPass{};
  QRhiRenderTarget* renderTarget{};
 
  operator bool() const noexcept { return texture != nullptr; }
 
  void release()
  {
    if(texture)
    {
      delete texture;
      texture = nullptr;
 
      delete colorRenderBuffer;
      colorRenderBuffer = nullptr;
 
      delete depthRenderBuffer;
      depthRenderBuffer = 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);
 
SCORE_PLUGIN_GFX_EXPORT
TextureRenderTarget createRenderTarget(
    const RenderState& state, QRhiTexture::Format fmt, QSize sz, int samples, bool depth,
    QRhiTexture::Flags = {});
 
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
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);
}