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;
 
        ~GL3ImageRenderer() = default;
 
        void UpdateBufferFormat(const OpenGLBufferFormat & bufferFormat) noexcept override;
 
        void * BeginBufferAccess(int & linePad) noexcept override
        {
          if (pixelBuffer_)
          {
            linePad = BufferFormat().LinePad;
            BindTexture();
            pixelBuffer_->Bind();
            pixelBuffer_->Data();
            return pixelBuffer_->Map();
          }
          else
            return nullptr;
        }
 
        void EndBufferAccess() noexcept override
        {
          if (pixelBuffer_)
          {
            pixelBuffer_->Unmap();
 
            Image2DTexture(nullptr, true);
            pixelBuffer_->Release();
            ReleaseTexture();
          }
 
        }
 
        bool MonoUploadSupported() const noexcept override
        {
          return true;
        }
 
      private:
 
 
        class GLPixelBuffer
          : public QOpenGLExtraFunctions
        {
          public:
 
            GLPixelBuffer() noexcept;
            ~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;
        };
        std::unique_ptr<GLPixelBuffer> pixelBuffer_;
 
 
    };
#endif
 
 
    class GL2ImageRenderer
      : public OpenGLImageRenderer
    {
      public:
 
        GL2ImageRenderer() noexcept
          : OpenGLImageRenderer()
        {
        }
 
        ~GL2ImageRenderer() = default;
 
        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);
    }
 
 
};
 
}
 
 
 
CVB_END_INLINE_NS
 
 
 
}