OutputNode.hpp

#pragma once
#include <Gfx/Graph/Node.hpp>
#include <Gfx/Graph/NodeRenderer.hpp>
#include <Gfx/Graph/RenderState.hpp>
#include <Gfx/Graph/Uniforms.hpp>
 
#include <score_plugin_gfx_export.h>
 
#include <memory>
 
namespace score::gfx
{
class GpuResourceRegistry;
struct OffscreenFrame;
struct OutputConfiguration
{
  GraphicsApi graphicsApi{};
  std::function<void()> onReady;
  std::function<void()> onResize;
 
  std::function<void()> onReleaseRenderList;
};
 
class SCORE_PLUGIN_GFX_EXPORT OutputNodeRenderer : public score::gfx::NodeRenderer
{
public:
  using score::gfx::NodeRenderer::NodeRenderer;
  virtual ~OutputNodeRenderer();
  virtual void
  finishFrame(RenderList&, QRhiCommandBuffer& commands, QRhiResourceUpdateBatch*& res);
 
  // Sinks have no output edges, so there is nothing to release per-edge.
  // Concrete sinks may still override, e.g. to drop per-input bookkeeping
  // routed through addOutputPass.
  void removeOutputPass(RenderList&, Edge&) override { }
};
 
class Window;
class SCORE_PLUGIN_GFX_EXPORT OutputNode : public score::gfx::Node
{
public:
  virtual ~OutputNode();
 
  virtual void setRenderer(std::shared_ptr<RenderList>) = 0;
  virtual RenderList* renderer() const = 0;
 
  OutputNodeRenderer* createRenderer(RenderList& r) const noexcept override = 0;
 
  virtual void startRendering() = 0;
  virtual void render() = 0;
  virtual void stopRendering() = 0;
  virtual bool canRender() const = 0;
  virtual void onRendererChange() = 0;
 
  virtual void setVSyncCallback(std::function<void()>);
 
  virtual void createOutput(OutputConfiguration conf) = 0;
 
  virtual void updateGraphicsAPI(GraphicsApi);
  virtual void destroyOutput() = 0;
  virtual std::shared_ptr<RenderState> renderState() const = 0;
 
  struct Configuration
  {
    // If set, the host is responsible for calling render() at this
    // rate (given in milliseconds)
    std::optional<double> manualRenderingRate;
    bool outputNeedsRenderPass{};
    bool supportsVSync{};
    // The host renders this output's RenderList itself, from its own frame
    // loop: GfxContext never calls render() on it.
    bool hostDriven{};
    OutputNode* parent{};
  };
 
  virtual Configuration configuration() const noexcept = 0;
 
  virtual TextureRenderTarget currentRenderTarget() const noexcept { return {}; }
 
  GpuResourceRegistry& acquireRegistry();
 
  GpuResourceRegistry* registry() const noexcept { return m_registry.get(); }
 
  void releaseRegistry();
 
  virtual bool deviceLost() const noexcept { return m_deviceLost; }
 
  void handleDeviceLost(const char* output) noexcept;
 
protected:
  bool checkDeviceLost(const OffscreenFrame& frame, QRhi& rhi, const char* output) noexcept;
  bool checkDeviceLost(int frameOpResult, QRhi& rhi, const char* output) noexcept;
 
  void resetDeviceLost() noexcept { m_deviceLost = false; }
 
  explicit OutputNode();
 
  void releaseOwnedRenderList();
 
  // Set by concrete createOutput() implementations from
  // OutputConfiguration::onReleaseRenderList.
  std::function<void()> m_onReleaseRenderList;
 
  // Persistent across RenderList rebuilds. See acquireRegistry() docs.
  // unique_ptr is opaque-typed in this header (forward-declared above);
  // its destructor needs the full type, hence the out-of-line ~OutputNode
  // implementation in OutputNode.cpp.
  std::unique_ptr<GpuResourceRegistry> m_registry;
 
  bool m_deviceLost{};
};
}