detail_opengl_image_renderer.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../_decl/decl_opengl_image_renderer.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
 
    inline void OpenGLImageRenderer::UpdateMaping(const QRectF &sourceRect, Size2D<int> textureRect) noexcept
    {
 
      OpenGLCoordArray coordArray;
 
      coordArray.TopLeft.VerPoint =
          QVector2D(static_cast<float>(sourceRect.left()), static_cast<float>(sourceRect.top()));
      coordArray.BottomLeft.VerPoint =
          QVector2D(static_cast<float>(sourceRect.left()), static_cast<float>(sourceRect.bottom()));
      coordArray.BottomRight.VerPoint =
          QVector2D(static_cast<float>(sourceRect.right()), static_cast<float>(sourceRect.bottom()));
      coordArray.TopRight.VerPoint =
          QVector2D(static_cast<float>(sourceRect.right()), static_cast<float>(sourceRect.top()));
 
      auto topAdjust    = static_cast<float>(sourceRect.top() - qFloor(sourceRect.top()));
      auto leftAdjust   = static_cast<float>(sourceRect.left() - qFloor(sourceRect.left()));
      auto bottomAdjust = static_cast<float>(qCeil(sourceRect.bottom()) - sourceRect.bottom());
      auto rightAdjust  = static_cast<float>(qCeil(sourceRect.right()) - sourceRect.right());
 
      if (textureRect.Width() && textureRect.Height())
      {
        topAdjust /= static_cast<float>(textureRect.Height());
        leftAdjust /= static_cast<float>(textureRect.Width());
        bottomAdjust /= static_cast<float>(textureRect.Height());
        rightAdjust /= static_cast<float>(textureRect.Width());
      }
 
      coordArray.TopLeft.TexPoint     = QVector2D(0.0f + leftAdjust, 0.0f + topAdjust);
      coordArray.BottomLeft.TexPoint  = QVector2D(0.0f + leftAdjust, 1.0f - bottomAdjust);
      coordArray.BottomRight.TexPoint = QVector2D(1.0f - rightAdjust, 1.0f - bottomAdjust);
      coordArray.TopRight.TexPoint    = QVector2D(1.0f - rightAdjust, 0.0f + topAdjust);
 
      coordBuffer_->Bind();
      coordBuffer_->Data(static_cast<int>(sizeof(OpenGLCoordArray)), &coordArray);
      coordBuffer_->Release();
    }
    inline void OpenGLImageRenderer::UpdateMaping(const QRectF &sourceRect, Size2D<int> textureRect) noexcept {…}
 
    inline void OpenGLImageRenderer::Render(const QRectF &rect) noexcept
    {
      if (!coordBuffer_ || !texture_)
        return;
 
      float nr  = -10.0f;
      float fr  = 10.0f;
      float r_l = static_cast<float>(rect.right() - rect.left());
      float t_b = static_cast<float>(rect.top() - rect.bottom());
      float f_n = fr - nr;
      float tx  = static_cast<float>(-(rect.right() + rect.left()) / (rect.right() - rect.left()));
      float ty  = static_cast<float>(-(rect.top() + rect.bottom()) / (rect.top() - rect.bottom()));
      float tz  = -(fr + nr) / (fr - nr);
 
      QMatrix4x4 modelView;  // NOLINT(cppcoreguidelines-init-variables)
      auto modelViewData = modelView.data();
 
      modelViewData[0] = 2.0f / r_l;
      modelViewData[1] = 0.0f;
      modelViewData[2] = 0.0f;
      modelViewData[3] = 0.0f;
 
      modelViewData[4] = 0.0f;
      modelViewData[5] = 2.0f / t_b;
      modelViewData[6] = 0.0f;
      modelViewData[7] = 0.0f;
 
      modelViewData[8]  = 0.0f;
      modelViewData[9]  = 0.0f;
      modelViewData[10] = 2.0f / f_n;
      modelViewData[11] = 0.0f;
 
      modelViewData[12] = tx;
      modelViewData[13] = ty;
      modelViewData[14] = tz;
      modelViewData[15] = 1.0;
 
      coordBuffer_->Bind();
      texture_->Bind();
      program_.bind();
 
      program_.setUniformValue(unifModelView_, modelView);
      program_.setUniformValue(unifTexture_, 0);
      program_.enableAttributeArray(attrVertex_);
      program_.enableAttributeArray(attrTexcoord_);
 
      program_.setAttributeBuffer(attrVertex_, GL_FLOAT, 0, 2,
                                  4 * sizeof(GL_FLOAT));  // NOLINT(bugprone-sizeof-expression)
      program_.setAttributeBuffer(attrTexcoord_, GL_FLOAT, 2 * sizeof(GL_FLOAT), 2,
                                  4 * sizeof(GL_FLOAT));  // NOLINT(bugprone-sizeof-expression)
 
      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
      program_.disableAttributeArray(attrTexcoord_);
      program_.disableAttributeArray(attrVertex_);
 
      program_.release();
      texture_->Release();
      coordBuffer_->Release();
    }
    inline void OpenGLImageRenderer::Render(const QRectF &rect) noexcept {…}
 
    inline OpenGLImageRenderer::OpenGLImageRenderer() noexcept
    {
      initializeOpenGLFunctions();
 
      program_.addShaderFromSourceCode(QOpenGLShader::Vertex,
                                       "#ifdef GL_ES\n"
                                       "// Set default precision to medium\n"
                                       "precision mediump int;\n"
                                       "precision mediump float;\n"
                                       "#endif\n"
                                       "\n"
                                       "uniform mat4 matrix;"
                                       "attribute vec2 coord2d;\n"
                                       "attribute vec2 texcoord;\n"
                                       "varying vec2 f_texcoord;\n"
                                       "void main(void)\n"
                                       "{\n"
                                       "  gl_Position = matrix * vec4(coord2d, 0.0, 1.0);\n"
                                       "  f_texcoord = texcoord;\n"
                                       "}");
 
      program_.addShaderFromSourceCode(QOpenGLShader::Fragment,
                                       "#ifdef GL_ES\n"
                                       "// Set default precision to medium\n"
                                       "precision mediump int;\n"
                                       "precision mediump float;\n"
                                       "#endif\n"
                                       "\n"
                                       "varying vec2 f_texcoord;"
                                       "uniform sampler2D texture;"
                                       "void main(void)"
                                       "{"
                                       "gl_FragColor = texture2D(texture, f_texcoord);"
                                       "}");
 
      program_.link();
 
      attrVertex_    = program_.attributeLocation("coord2d");   // NOLINT(cppcoreguidelines-prefer-member-initializer)
      attrTexcoord_  = program_.attributeLocation("texcoord");  // NOLINT(cppcoreguidelines-prefer-member-initializer)
      unifModelView_ = program_.uniformLocation("matrix");      // NOLINT(cppcoreguidelines-prefer-member-initializer)
      unifTexture_   = program_.uniformLocation("texture");     // NOLINT(cppcoreguidelines-prefer-member-initializer)
 
      program_.bind();
 
      coordBuffer_.reset(new (std::nothrow) GLCoordBuffer);  // NOLINT(cppcoreguidelines-owning-memory)
      if (coordBuffer_)
      {
        coordBuffer_->Bind();
        OpenGLCoordArray coordArray;
        coordBuffer_->Data(static_cast<int>(sizeof(OpenGLCoordArray)), &coordArray);
        coordBuffer_->Release();
      }
 
      texture_.reset(new (std::nothrow) GLTexture);  // NOLINT(cppcoreguidelines-owning-memory)
 
      program_.release();
    }
 
    inline void OpenGLImageRenderer::BindTexture() noexcept
    {
      texture_->Bind();
    }
 
    inline void OpenGLImageRenderer::ReleaseTexture() noexcept
    {
      texture_->Release();
    }
 
    inline void OpenGLImageRenderer::Image2DTexture(const OpenGLBufferFormat &pixelBufferFormat, void *pixels,
                                                    bool swizzleSupport) noexcept
    {
      texture_->Image2D(pixelBufferFormat, pixels, swizzleSupport);
    }
 
    inline void OpenGLImageRenderer::Image2DTexture(void *pixels, bool swizzleSupport) noexcept
    {
      texture_->Image2D(pixels, swizzleSupport);
    }
 
    inline OpenGLImageRenderer::GLTexture::GLTexture() noexcept
    {
      initializeOpenGLFunctions();
      glGenTextures(1, &handle_);
    }
 
    inline OpenGLImageRenderer::GLTexture::~GLTexture()
    {
      glDeleteTextures(1, &handle_);
    }
 
    inline void OpenGLImageRenderer::GLTexture::Bind() noexcept
    {
      glBindTexture(GL_TEXTURE_2D, handle_);
    }
 
    inline void OpenGLImageRenderer::GLTexture::Release() noexcept
    {
      glBindTexture(GL_TEXTURE_2D, 0);
    }
 
    inline void OpenGLImageRenderer::GLTexture::Image2D(const OpenGLBufferFormat &pixelBufferFormat, void *pixels,
                                                        bool swizzleSupport) noexcept
    {
      pixelBufferFormat_ = pixelBufferFormat;
      Image2D(pixels, swizzleSupport);
    }
 
    inline void OpenGLImageRenderer::GLTexture::Image2D(void *pixels, bool swizzleSupport) noexcept
    {
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
      if (swizzleSupport)
      {
        if (pixelBufferFormat_.TextureFormat == OpenGLTextureFormat::Mono)
        {
 
          std::array<GLint, 4> swizzleMask = {GL_RED, GL_RED, GL_RED, GL_ALPHA};
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &swizzleMask[0]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &swizzleMask[1]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &swizzleMask[2]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &swizzleMask[3]);
        }
        else
        {
          std::array<GLint, 4> swizzleMask = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA};
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, &swizzleMask[0]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, &swizzleMask[1]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, &swizzleMask[2]);
          glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, &swizzleMask[3]);
        }
      }
 
      glTexImage2D(GL_TEXTURE_2D, 0,
                   (pixelBufferFormat_.TextureFormat == OpenGLTextureFormat::RGB || !swizzleSupport) ? GL_RGBA : GL_RED,
                   static_cast<GLsizei>(pixelBufferFormat_.Width), static_cast<GLsizei>(pixelBufferFormat_.Height), 0,
                   (pixelBufferFormat_.TextureFormat == OpenGLTextureFormat::RGB || !swizzleSupport) ? GL_RGBA : GL_RED,
                   GL_UNSIGNED_BYTE, pixels);
    }
 
    inline OpenGLImageRenderer::GLCoordBuffer::GLCoordBuffer() noexcept
    {
      initializeOpenGLFunctions();
      glGenBuffers(1, &handle_);
    }
 
    inline OpenGLImageRenderer::GLCoordBuffer::~GLCoordBuffer()
    {
      glDeleteBuffers(1, &handle_);
    }
 
    inline void OpenGLImageRenderer::GLCoordBuffer::Bind() noexcept
    {
      glBindBuffer(GL_ARRAY_BUFFER, handle_);
    }
 
    inline void OpenGLImageRenderer::GLCoordBuffer::Release() noexcept
    {
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
 
    inline void OpenGLImageRenderer::GLCoordBuffer::Data(int size, void *buffer) noexcept
    {
      glBufferData(GL_ARRAY_BUFFER, static_cast<qopengl_GLsizeiptr>(size), buffer, GL_STREAM_DRAW);
    }
 
  }  // namespace UI
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb