decl_image_scene.hpp

#pragma once
 
#include <atomic>
 
#ifdef _MSC_VER
#  pragma warning(push, 1)
#  pragma warning(disable : 4127)
#endif
 
#include <QGraphicsScene>
#include <QPainter>
#include <QSize>
#include <QRect>
#include <QWidget>
#include <QOpenGLFunctions>
#include <QOpenGLWidget>
#include <QtMath>
#include <QThread>
#include <QApplication>
 
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
 
#include "../../global.hpp"
 
#include "../ui.hpp"
 
#include "../../driver/driver.hpp"
 
#include "decl_opengl_image_renderer.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {


    class ImageScene : public QGraphicsScene
    {
      friend Cvb::UI::ImageView;
 
    public:

      explicit ImageScene(QObject *parent = nullptr)
          : QGraphicsScene(parent)
          , syncUploadRequired_(false)
      {
        engine_ = std::unique_ptr<Engine>(new RasterEngine(*this));
      }
      explicit ImageScene(QObject *parent = nullptr) {…}
 
      Cvb::UI::RenderEngine RenderEngine() const noexcept
      {
        return engine_->RenderEngine();
      }
 
      void SetRenderEngine(Cvb::UI::RenderEngine renderEngine);
 
    protected:

      virtual void UploadImage(const Image &image) noexcept;


      class ImageView *ImageView() noexcept;
 
      void Render(QPainter *painter, const QRectF &rect) noexcept
      {
        engine_->Render(painter, rect);
      }
 
      std::unique_ptr<Image> UpdateRenderTarget(const Image &image) noexcept
      {
        return engine_->UpdateRenderTarget(image);
      }
 
      void CopyImageData(const Image &image) noexcept
      {
        engine_->CopyImageData(image);
      }
 
      void UpdateSceneRect(const Image &image) noexcept;
 
      void ScheduleSyncUpload() noexcept
      {
        syncUploadRequired_ = true;
      }
 
    private:
      class Engine
      {
      public:
        explicit Engine(class ImageScene &imageScene) noexcept
            : imageScene_(imageScene)
        {
        }
 
        Engine(const Engine &other)            = delete;
        Engine &operator=(const Engine &other) = delete;
        Engine(Engine &&other)                 = delete;
        Engine &operator=(Engine &&other)      = delete;
        virtual ~Engine()                      = default;
 
        virtual void Render(QPainter *painter, const QRectF &rect) noexcept = 0;
 
        virtual std::unique_ptr<Image> UpdateRenderTarget(const Image &image) noexcept = 0;
 
        virtual void CopyImageData(const Image &image) noexcept = 0;
 
        virtual Cvb::UI::RenderEngine RenderEngine() const noexcept = 0;
 
        virtual QWidget *CreateViewport() = 0;
 
        virtual void ViewPortSetup() {}
 
      protected:
        class ImageScene &ImageScene() const noexcept
        {
          return imageScene_;
        }
 
      private:
        class ImageScene &imageScene_;
      };
 
      class RasterEngine : public Engine
      {
      public:
        explicit RasterEngine(class ImageScene &imageScene) noexcept
            : Engine(imageScene)
        {
        }
 
      private:
        void Render(QPainter *painter, const QRectF &rect) noexcept override;
 
        std::unique_ptr<Image> UpdateRenderTarget(const Image &image) noexcept override;
 
        void CopyImageData(const Image &image) noexcept override;
 
        Cvb::UI::RenderEngine RenderEngine() const noexcept override
        {
          return Cvb::UI::RenderEngine::Raster;
        }
 
        QWidget *CreateViewport() override
        {
          return new QWidget();
        }
 
        QImage screenImage_;
        QRectF screenImageRect_;
      };
 
      class GLViewport;
 
      class GLEngine
          : public Engine
          , protected QOpenGLFunctions
      {
        friend class ImageScene::GLViewport;
 
      public:
        GLEngine(class ImageScene &imageScene, Cvb::UI::RenderEngine renderEngine) noexcept
            : Engine(imageScene)
            , renderEngine_(renderEngine)
        {
          // get a clear color that looks like a standard widget background.
          QWidget w;
          clearColor_ = w.palette().color(w.backgroundRole());
        }
 
      private:
        void Render(QPainter *painter, const QRectF &rect) noexcept override;
 
        std::unique_ptr<Image> UpdateRenderTarget(const Image &image) noexcept override;
 
        void CopyImageData(const Image &image) noexcept override;
 
        Cvb::UI::RenderEngine RenderEngine() const noexcept override
        {
          return renderEngine_;
        }
 
        QWidget *CreateViewport() override;
 
        void ViewPortSetup() override;
 
        void MakeCurrent() noexcept;
 
        Cvb::UI::RenderEngine renderEngine_;
 
        std::unique_ptr<OpenGLImageRenderer> renderer_;
 
        QColor clearColor_;
      };
 
      class GLViewport : public QOpenGLWidget
      {
      public:
        explicit GLViewport(GLEngine &glEngine)
            : QOpenGLWidget()
            , glEngine_(glEngine)
        {
        }
 
      private:
        void initializeGL() override
        {
          // does not throw!
          glEngine_.ViewPortSetup();
        }
 
        GLEngine &glEngine_;
      };
 
      void drawBackground(QPainter *painter, const QRectF &rect) override;
 
      std::atomic<bool> syncUploadRequired_;
 
      std::mutex renderMutex_;
 
      std::unique_ptr<Engine> engine_;
    };
    class ImageScene : public QGraphicsScene {…};
 
  }  // namespace UI
  namespace UI {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb