RenderList.hpp

#pragma once
#include <Gfx/Graph/CommonUBOs.hpp>
#include <Gfx/Graph/Node.hpp>
 
namespace score::gfx
{
 
class OutputNode;
class SCORE_PLUGIN_GFX_EXPORT RenderList
{
private:
  std::shared_ptr<RenderState> m_state;
 
public:
  explicit RenderList(OutputNode& output, const std::shared_ptr<RenderState>& state);
  ~RenderList();
 
  void init();
 
  [[nodiscard]] QRhiResourceUpdateBatch* initialBatch() const noexcept;
 
  MeshBuffers initMeshBuffer(const Mesh& mesh, QRhiResourceUpdateBatch& res);
 
  void update(QRhiResourceUpdateBatch& res);
 
  void render(QRhiCommandBuffer& commands, bool force = false);
 
  void release();
 
  void maybeRebuild();
 
  TextureRenderTarget renderTargetForOutput(const Edge& edge) noexcept;
 
  QImage adaptImage(const QImage& in);
 
  OutputNode& output;
 
  RenderState& state;
 
  using Buffers = std::pair<const Mesh* const, MeshBuffers>;
  Buffers acquireMesh(
      const ossia::geometry_spec&, QRhiResourceUpdateBatch& res, const Mesh* current,
      MeshBuffers currentbufs) noexcept;
 
  std::vector<score::gfx::Node*> nodes;
 
  std::vector<score::gfx::NodeRenderer*> renderers;
 
  void clearRenderers();
 
  QRhiTexture& emptyTexture() const noexcept { return *m_emptyTexture; }
 
  QRhiBuffer& outputUBO() const noexcept { return *m_outputUBO; }
 
  const score::gfx::Mesh& defaultQuad() const noexcept;
 
  const score::gfx::Mesh& defaultTriangle() const noexcept;
 
  int samples() const noexcept { return m_samples; }
 
  bool canRender() const noexcept { return m_ready; }
 
private:
  OutputUBO m_outputUBOData;
 
  QRhiResourceUpdateBatch* m_initialBatch{};
  // Material
  QRhiBuffer* m_outputUBO{};
  QRhiTexture* m_emptyTexture{};
 
  ossia::flat_map<Mesh*, MeshBuffers> m_vertexBuffers;
 
  ossia::flat_map<ossia::geometry_spec, Mesh*> m_customMeshCache;
 
  QSize m_lastSize{};
 
  int m_minTexSize{};
  int m_maxTexSize{};
  int m_samples{1};
 
  bool m_flip{};
 
  bool m_ready{};
  bool m_built{};
};
}