detail_opengl_image_renderer_factory.hpp

#pragma once
 
#include <stdexcept>
#include <sstream>
 
#include "../../global.hpp"
 
#include "../_decl/decl_opengl_image_renderer_factory.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
 
    inline std::unique_ptr<OpenGLImageRenderer> OpenGLImageRendererFactory::CreateRenderer(int version)
    {
      switch (version)
      {
        default:
          throw std::runtime_error("unsupported render engine - check your system");
 
        case 2:
          return std::make_unique<GL2ImageRenderer>();
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
        case 3:
          return std::make_unique<GL3ImageRenderer>();
#endif
      }
    }
    inline std::unique_ptr<OpenGLImageRenderer> OpenGLImageRendererFactory::CreateRenderer(int version) {…}
 
    inline QSurfaceFormat OpenGLImageRendererFactory::CreateFormat(int version)
    {
      QSurfaceFormat format;
      if (TryVersion(version, format))
        return format;
 
      std::stringstream stream;
      stream << "failed to create format for OpenGL " << version;
 
      throw std::runtime_error(stream.str().c_str());
    }
    inline QSurfaceFormat OpenGLImageRendererFactory::CreateFormat(int version) {…}
 
    inline bool OpenGLImageRendererFactory::TryVersion(int version) noexcept
    {
      QSurfaceFormat format;
      return TryVersion(version, format);
    }
    inline bool OpenGLImageRendererFactory::TryVersion(int version) noexcept {…}
 
    inline bool OpenGLImageRendererFactory::TryVersion(int version, QSurfaceFormat &format) noexcept
    {
      QSurfaceFormat formatA;
      // compatible format for raster engine if qt version is < 5.8.x
      formatA.setProfile(QSurfaceFormat::CompatibilityProfile);
      if (TryFormat(formatA, version))
      {
        format = formatA;
        return true;
      }
 
      QSurfaceFormat formatB;
      if (TryFormat(formatB, version))
      {
        format = formatB;
        return true;
      }
 
      QSurfaceFormat formatC;
      formatC.setVersion(version, 0);
      if (TryFormat(formatC, version))
      {
        format = formatC;
        return true;
      }
 
      return false;
    }
    inline bool OpenGLImageRendererFactory::TryVersion(int version, QSurfaceFormat &format) noexcept {…}
 
    inline String OpenGLImageRendererFactory::VendorName(int version)
    {
      return ReadString(version, GL_VENDOR);
    }
    inline String OpenGLImageRendererFactory::VendorName(int version) {…}
 
    inline String OpenGLImageRendererFactory::RendererName(int version)
    {
      return ReadString(version, GL_RENDERER);
    }
    inline String OpenGLImageRendererFactory::RendererName(int version) {…}
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
    inline OpenGLImageRendererFactory::GL3ImageRenderer::GL3ImageRenderer() noexcept
        : OpenGLImageRenderer()
    {
    }
 
    inline void
    OpenGLImageRendererFactory::GL3ImageRenderer::UpdateBufferFormat(const OpenGLBufferFormat &bufferFormat) noexcept
    {
      SetBufferFormat(bufferFormat);
 
      BindTexture();
      Image2DTexture(bufferFormat, nullptr, true);
      ReleaseTexture();
 
      auto size = bufferFormat.Height * (bufferFormat.Width + bufferFormat.LinePad);
 
      pixelBuffer_.Bind();
      pixelBuffer_.Data(size << ((bufferFormat.TextureFormat == OpenGLTextureFormat::Mono) ? 0 : 2));
      pixelBuffer_.Release();
    }
 
    inline OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::GLPixelBuffer() noexcept
    {
      initializeOpenGLFunctions();
      glGenBuffers(1, &handle_);
    }
 
    inline OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::~GLPixelBuffer()
    {
      glDeleteBuffers(1, &handle_);
    }
 
    inline void OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Bind() noexcept
    {
      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, handle_);
    }
 
    inline void OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Release() noexcept
    {
      glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
    }
 
    inline void OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Data() noexcept
    {
      glBufferData(GL_PIXEL_UNPACK_BUFFER, static_cast<qopengl_GLsizeiptr>(size_), 0, GL_STREAM_DRAW);
    }
 
    inline void OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Data(int size) noexcept
    {
      size_ = size;
      glBufferData(GL_PIXEL_UNPACK_BUFFER, static_cast<qopengl_GLsizeiptr>(size_), 0, GL_STREAM_DRAW);
    }
 
    inline void *OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Map() noexcept
    {
 
      return glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, static_cast<GLsizeiptr>(size_), GL_MAP_WRITE_BIT);
    }
 
    inline void OpenGLImageRendererFactory::GL3ImageRenderer::GLPixelBuffer::Unmap() noexcept
    {
      glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
    }
#endif
 
    inline void
    OpenGLImageRendererFactory::GL2ImageRenderer::UpdateBufferFormat(const OpenGLBufferFormat &bufferFormat) noexcept
    {
      SetBufferFormat(bufferFormat);
      auto size = bufferFormat.Height * (bufferFormat.Width);
      std::vector<std::uint8_t>(size << 2).swap(pixelBuffer_);
    }
 
  }  // namespace UI
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb