ScreenNode.hpp

#pragma once
#include <atomic>
#include <Gfx/Graph/OutputNode.hpp>
#include <Gfx/Window/WindowSettings.hpp>
 
class QScreen;
class QTabletEvent;
namespace score::gfx
{
struct SCORE_PLUGIN_GFX_EXPORT ScreenNode : OutputNode
{
  explicit ScreenNode(Configuration conf, bool embedded = false, bool startFullScreen = false);
  virtual ~ScreenNode();
 
  void startRendering() override;
  void render() override;
  void onRendererChange() override;
  bool canRender() const override;
  void stopRendering() override;
 
  void setRenderer(std::shared_ptr<RenderList> r) override;
  RenderList* renderer() const override;
 
  void setScreen(QScreen*);
  void setPosition(QPoint pos);
  void setSize(QSize sz);
  void setRenderSize(QSize sz);
  void setFullScreen(bool);
  void setCursor(bool);
  void setTitle(QString);
  void setConfiguration(Configuration);
  void setSwapchainFlag(Gfx::SwapchainFlag flag);
  void setSwapchainFormat(Gfx::SwapchainFormat format);
 
  void createOutput(score::gfx::OutputConfiguration) override;
  void destroyOutput() override;
  void updateGraphicsAPI(GraphicsApi) override;
  void setVSyncCallback(std::function<void()>) override;
 
  std::shared_ptr<RenderState> renderState() const override;
  score::gfx::OutputNodeRenderer* createRenderer(RenderList& r) const noexcept override;
  Configuration configuration() const noexcept override;
  bool deviceLost() const noexcept override;
 
  const std::shared_ptr<Window>& window() const noexcept { return m_window; }
 
  // Readback of the on-screen frame. QScreen::grabWindow reads the desktop at
  // the window's geometry, so it captures whatever is in front of the window;
  // this reads the swapchain's own backbuffer instead. It costs a full-frame
  // copy, so the renderer only issues it when requestReadback() has armed it.
  void requestReadback() const noexcept { m_readbackRequested.store(true); }
  bool takeReadbackRequest() const noexcept
  {
    return m_readbackRequested.exchange(false);
  }
  const std::shared_ptr<QRhiReadbackResult>& readback() const noexcept
  {
    return m_readback;
  }
 
  std::function<void(QPointF)> onWindowMove;
  std::function<void(QPointF, QPointF)> onMouseMove;
  std::function<void(QTabletEvent*)> onTabletMove;
  std::function<void()> onPointersChanged;
  std::function<void(int, const QString&)> onKey;
  std::function<void(int, const QString&)> onKeyRelease;
  std::function<void(float)> onFps;
 
private:
  // Frees this output's QRhi device and everything built on it (swap chain,
  // depth-stencil, render pass descriptor, registry), keeping the window.
  void releaseDevice();
 
  Configuration m_conf;
  mutable std::atomic_bool m_readbackRequested{false};
  std::shared_ptr<QRhiReadbackResult> m_readback
      = std::make_shared<QRhiReadbackResult>();
  std::shared_ptr<Window> m_window{};
  QRhiSwapChain* m_swapChain{};
  QRhiRenderBuffer* m_depthStencil{};
  QScreen* m_screen{};
  QString m_title;
  std::optional<QPoint> m_pos{};
  std::optional<QSize> m_sz{};
  std::optional<QSize> m_renderSz{};
  std::function<void()> m_vsyncCallback;
 
  Gfx::SwapchainFlag m_swapchainFlag{};
  Gfx::SwapchainFormat m_swapchainFormat{};
  bool m_embedded{};
  bool m_fullScreen{};
  bool m_ownsWindow{};
};
}