decl_opengl_image_renderer_factory.hpp

#pragma once
 
#ifdef _MSC_VER
#  pragma warning(push, 1)
#  pragma warning(disable : 4127)
#  pragma warning(disable : 4005)  // macro redefinition // TODO
#endif
 
#include <QSurfaceFormat>
#include <QOffscreenSurface>
#include <QScreen>
#include <QSysInfo>
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
#  include <QOpenGLExtraFunctions>
#endif
 
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
 
#include "../../global.hpp"
 
#include "../ui.hpp"
 
#include "decl_opengl_image_renderer.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {


    class OpenGLImageRendererFactory final
    {
    public:

      static std::unique_ptr<OpenGLImageRenderer> CreateRenderer(int version);


      static QSurfaceFormat CreateFormat(int version);


      static bool TryVersion(int version) noexcept;


      static bool TryVersion(int version, QSurfaceFormat &format) noexcept;


      static String VendorName(int version);


      static String RendererName(int version);
 
    private:
#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
      class GL3ImageRenderer : public OpenGLImageRenderer
      {
      public:
        GL3ImageRenderer() noexcept;
 
        void UpdateBufferFormat(const OpenGLBufferFormat &bufferFormat) noexcept override;
 
        void *BeginBufferAccess(int &linePad) noexcept override
        {
 
          linePad = BufferFormat().LinePad;
          BindTexture();
          pixelBuffer_.Bind();
          pixelBuffer_.Data();
          return pixelBuffer_.Map();
        }
 
        void EndBufferAccess() noexcept override
        {
 
          pixelBuffer_.Unmap();
 
          Image2DTexture(nullptr, true);
          pixelBuffer_.Release();
          ReleaseTexture();
        }
 
        bool MonoUploadSupported() const noexcept override
        {
          return true;
        }
 
      private:
        class GLPixelBuffer : public QOpenGLExtraFunctions
        {
        public:
          GLPixelBuffer() noexcept;
          GLPixelBuffer(const GLPixelBuffer &other)            = delete;
          GLPixelBuffer &operator=(const GLPixelBuffer &other) = delete;
          GLPixelBuffer(GLPixelBuffer &&other)                 = delete;
          GLPixelBuffer &operator=(GLPixelBuffer &&other)      = delete;
          ~GLPixelBuffer();
 
          void Bind() noexcept;
          void Release() noexcept;
 
          void Data() noexcept;
          void Data(int size) noexcept;
 
          void *Map() noexcept;
          void Unmap() noexcept;
 
        private:
          GLuint handle_ = 0;
 
          int size_ = 0;
        };
        GLPixelBuffer pixelBuffer_;
      };
#endif
 
      class GL2ImageRenderer : public OpenGLImageRenderer
      {
      public:
        GL2ImageRenderer() noexcept
            : OpenGLImageRenderer()
        {
        }
 
        void UpdateBufferFormat(const OpenGLBufferFormat &bufferFormat) noexcept override;
 
        void *BeginBufferAccess(int & /*linePad*/) noexcept override
        {
          return &pixelBuffer_[0];
        }
 
        void EndBufferAccess() noexcept override
        {
          BindTexture();
          Image2DTexture(BufferFormat(), &pixelBuffer_[0], false);
          ReleaseTexture();
        }
 
        bool MonoUploadSupported() const noexcept override
        {
          return false;
        }
 
      private:
        std::vector<std::uint8_t> pixelBuffer_;
      };
 
      OpenGLImageRendererFactory() noexcept = delete;
 
      static bool TryFormat(const QSurfaceFormat &format, int minVersion) noexcept
      {
        QOpenGLContext context;
        context.setFormat(format);
        if (!context.create())
          return false;
 
        auto effectiveFormat = context.format();
        if (effectiveFormat.majorVersion() < minVersion  // we did not get what is needed
                                                         // we got OpenGL ES 3 outside arm, this will not work
            || (effectiveFormat.majorVersion() == 3 && effectiveFormat.renderableType() == QSurfaceFormat::OpenGLES
                && !(QSysInfo::currentCpuArchitecture().startsWith("arm")))
            // we got OpenGL 2 (not ES) this will not work either
            || (effectiveFormat.majorVersion() == 2 && effectiveFormat.renderableType() != QSurfaceFormat::OpenGLES))
          return false;
        if (effectiveFormat.profile() == QSurfaceFormat::CoreProfile)
          return false;
 
        return true;
      }
 
      static String ReadString(int version, int value)
      {
        auto format = CreateFormat(version);
 
        QOpenGLContext context;
        context.setFormat(format);
        if (!context.create())
          throw std::runtime_error("failed to create context for already verified OpenGL version.");
 
        QOffscreenSurface surface;
        context.makeCurrent(&surface);
        QOpenGLFunctions fnc;
        fnc.initializeOpenGLFunctions();
 
        QString vendor(reinterpret_cast<const char *>(fnc.glGetString(static_cast<GLenum>(value))));
        return QtToCvb(vendor);
      }
    };
    class OpenGLImageRendererFactory final {…};
 
  }  // namespace UI
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb