mirror
/
sdrangel
kopia lustrzana https://github.com/f4exb/sdrangel
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
sdrangel/sdrgui/gui/glshadertvarray.cpp

423 wiersze
12 KiB
C++
Czysty Bezpośredni odnośnik Wina Historia

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2017-2020, 2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
// Copyright (C) 2020 Vort <vvort@yandex.ru> //
// Copyright (C) 2022 Jon Beniston, M7RCE <jon@beniston.com> //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
///////////////////////////////////////////////////////////////////////////////////
#include <QOpenGLContext>
#include "gui/glshadertvarray.h"
const QString GLShaderTVArray::m_strVertexShaderSourceArray2 = QString(
"uniform highp mat4 uMatrix;\n"
"attribute highp vec4 vertex;\n"
"attribute highp vec2 texCoord;\n"
"varying mediump vec2 texCoordVar;\n"
"void main() {\n"
" gl_Position = uMatrix * vertex;\n"
" texCoordVar = texCoord;\n"
"}\n");
const QString GLShaderTVArray::m_strVertexShaderSourceArray = QString(
"#version 330\n"
"uniform highp mat4 uMatrix;\n"
"in highp vec4 vertex;\n"
"in highp vec2 texCoord;\n"
"out mediump vec2 texCoordVar;\n"
"void main() {\n"
" gl_Position = uMatrix * vertex;\n"
" texCoordVar = texCoord;\n"
"}\n");
const QString GLShaderTVArray::m_strFragmentShaderSourceColored2 = QString(
"uniform lowp sampler2D uTexture;\n"
"varying mediump vec2 texCoordVar;\n"
"void main() {\n"
" gl_FragColor = texture2D(uTexture, texCoordVar);\n"
"}\n");
const QString GLShaderTVArray::m_strFragmentShaderSourceColored = QString(
"#version 330\n"
"uniform lowp sampler2D uTexture;\n"
"in mediump vec2 texCoordVar;\n"
"out vec4 fragColor;\n"
"void main() {\n"
" fragColor = texture(uTexture, texCoordVar);\n"
"}\n");
GLShaderTVArray::GLShaderTVArray(bool blnColor) :
m_objProgram(nullptr),
m_vao(nullptr),
m_verticesBuf(nullptr),
m_textureCoordsBuf(nullptr),
m_matrixLoc(0),
m_textureLoc(0),
m_objImage(nullptr),
m_objTexture(nullptr),
m_intCols(0),
m_intRows(0),
m_objCurrentRow(nullptr),
m_blnInitialized(false),
m_blnColor(blnColor),
m_blnAlphaBlend(false),
m_blnAlphaReset(false)
{
}
GLShaderTVArray::~GLShaderTVArray()
{
qDebug("GLShaderTVArray::~GLShaderTVArray");
cleanup();
}
void GLShaderTVArray::initializeGL(int majorVersion, int minorVersion, int intCols, int intRows)
{
QMatrix4x4 objQMatrix;
m_blnInitialized = false;
m_intCols = 0;
m_intRows = 0;
m_objCurrentRow = nullptr;
if (!m_objProgram)
{
m_objProgram = new QOpenGLShaderProgram();
if ((majorVersion > 3) || ((majorVersion == 3) && (minorVersion >= 3)))
{
if (!m_objProgram->addShaderFromSourceCode(QOpenGLShader::Vertex,
m_strVertexShaderSourceArray))
{
qDebug() << "GLShaderArray::initializeGL: error in vertex shader: "
<< m_objProgram->log();
}
if (!m_objProgram->addShaderFromSourceCode(QOpenGLShader::Fragment,
m_strFragmentShaderSourceColored))
{
qDebug()
<< "GLShaderArray::initializeGL: error in fragment shader: "
<< m_objProgram->log();
}
m_vao = new QOpenGLVertexArrayObject();
m_vao->create();
m_vao->bind();
}
else
{
if (!m_objProgram->addShaderFromSourceCode(QOpenGLShader::Vertex,
m_strVertexShaderSourceArray2))
{
qDebug() << "GLShaderArray::initializeGL: error in vertex shader: "
<< m_objProgram->log();
}
if (!m_objProgram->addShaderFromSourceCode(QOpenGLShader::Fragment,
m_strFragmentShaderSourceColored2))
{
qDebug()
<< "GLShaderArray::initializeGL: error in fragment shader: "
<< m_objProgram->log();
}
}
m_objProgram->bindAttributeLocation("vertex", 0);
if (!m_objProgram->link())
{
qDebug() << "GLShaderArray::initializeGL: error linking shader: "
<< m_objProgram->log();
}
m_objProgram->bind();
m_objProgram->setUniformValue(m_matrixLoc, objQMatrix);
m_objProgram->setUniformValue(m_textureLoc, 0);
if (m_vao)
{
m_verticesBuf = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
m_verticesBuf->setUsagePattern(QOpenGLBuffer::DynamicDraw);
m_verticesBuf->create();
m_textureCoordsBuf = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
m_textureCoordsBuf->setUsagePattern(QOpenGLBuffer::DynamicDraw);
m_textureCoordsBuf->create();
m_vao->release();
}
m_objProgram->release();
}
m_matrixLoc = m_objProgram->uniformLocation("uMatrix");
m_textureLoc = m_objProgram->uniformLocation("uTexture");
if (m_objTexture)
{
delete m_objTexture;
m_objTexture = nullptr;
}
//Image container
m_objImage = new QImage(intCols, intRows, QImage::Format_RGBA8888);
m_objImage->fill(QColor(0, 0, 0));
m_objTexture = new QOpenGLTexture(*m_objImage);
//m_objTexture->setFormat(QOpenGLTexture::RGBA8_UNorm); avoids OpenGL warning and in fact is useless
m_objTexture->setMinificationFilter(QOpenGLTexture::Linear);
m_objTexture->setMagnificationFilter(QOpenGLTexture::Linear);
m_objTexture->setWrapMode(QOpenGLTexture::ClampToEdge);
m_intCols = intCols;
m_intRows = intRows;
m_blnInitialized = true;
}
QRgb *GLShaderTVArray::GetRowBuffer(int intRow)
{
if (!m_blnInitialized) {
return nullptr;
}
if (!m_objImage) {
return nullptr;
}
if (intRow > m_intRows) {
return nullptr;
}
return (QRgb *) m_objImage->scanLine(intRow);
}
void GLShaderTVArray::RenderPixels(unsigned char *chrData)
{
QOpenGLFunctions *ptrF;
int intI;
int intJ;
int intNbVertices = 6;
QMatrix4x4 objQMatrix;
GLfloat arrVertices[] =
// 2 3
// 1 4
//1 2 3 3 4 1
{ -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f };
GLfloat arrTextureCoords[] =
// 1 4
// 2 3
//1 2 3 3 4 1
{ 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f };
QRgb *ptrLine;
int intVal;
if (!m_blnInitialized) {
return;
}
if (!m_objImage) {
return;
}
if (chrData != 0)
{
for (intJ = 0; intJ < m_intRows; intJ++)
{
ptrLine = (QRgb *) m_objImage->scanLine(intJ);
for (intI = 0; intI < m_intCols; intI++)
{
if (m_blnColor)
{
*ptrLine = qRgb((int) (*(chrData+2)), (int) (*(chrData+1)), (int) (*chrData));
chrData+=3;
}
else
{
intVal = (int) (*chrData);
*ptrLine = qRgb(intVal, intVal, intVal);
chrData++;
}
ptrLine++;
}
}
}
//Affichage
ptrF = QOpenGLContext::currentContext()->functions();
m_objProgram->bind();
m_objProgram->setUniformValue(m_matrixLoc, objQMatrix);
m_objProgram->setUniformValue(m_textureLoc, 0);
if (m_blnAlphaReset)
{
ptrF->glClear(GL_COLOR_BUFFER_BIT);
m_blnAlphaReset = false;
}
if (m_blnAlphaBlend)
{
ptrF->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
ptrF->glEnable(GL_BLEND);
}
else
{
ptrF->glDisable(GL_BLEND);
}
m_objTexture->bind();
ptrF->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_intCols, m_intRows, GL_RGBA,
GL_UNSIGNED_BYTE, m_objImage->bits());
if (m_vao)
{
m_vao->bind();
m_verticesBuf->bind();
m_verticesBuf->allocate(arrVertices, intNbVertices * 2 * sizeof(GL_FLOAT));
m_objProgram->enableAttributeArray(0);
m_objProgram->setAttributeBuffer(0, GL_FLOAT, 0, 2);
m_textureCoordsBuf->bind();
m_textureCoordsBuf->allocate(arrTextureCoords, intNbVertices * 2 * sizeof(GL_FLOAT));
m_objProgram->enableAttributeArray(1);
m_objProgram->setAttributeBuffer(1, GL_FLOAT, 0, 2);
}
else
{
ptrF->glEnableVertexAttribArray(0); // vertex
ptrF->glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, arrVertices);
ptrF->glEnableVertexAttribArray(1); // texture coordinates
ptrF->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, arrTextureCoords);
}
ptrF->glDrawArrays(GL_TRIANGLES, 0, intNbVertices);
//cleanup
if (m_vao)
{
m_vao->release();
}
else
{
ptrF->glDisableVertexAttribArray(0);
ptrF->glDisableVertexAttribArray(1);
}
//*********************//
m_objTexture->release();
m_objProgram->release();
}
void GLShaderTVArray::ResetPixels()
{
if (m_objImage) {
m_objImage->fill(0);
}
}
void GLShaderTVArray::ResetPixels(int alpha)
{
if (m_objImage) {
m_objImage->fill(qRgba(0, 0, 0, alpha));
}
}
void GLShaderTVArray::cleanup()
{
m_blnInitialized = false;
m_intCols = 0;
m_intRows = 0;
m_objCurrentRow = nullptr;
if (!QOpenGLContext::currentContext()) {
return;
}
if (m_objProgram)
{
delete m_objProgram;
m_objProgram = nullptr;
}
if (m_objTexture)
{
delete m_objTexture;
m_objTexture = nullptr;
}
if (m_objImage)
{
delete m_objImage;
m_objImage = nullptr;
}
delete m_verticesBuf;
m_verticesBuf = nullptr;
delete m_textureCoordsBuf;
m_textureCoordsBuf = nullptr;
delete m_vao;
m_vao = nullptr;
}
bool GLShaderTVArray::SelectRow(int intLine)
{
bool blnRslt = false;
if (m_blnInitialized)
{
if ((intLine < m_intRows) && (intLine >= 0))
{
m_objCurrentRow = (QRgb *) m_objImage->scanLine(intLine);
blnRslt = true;
}
else
{
m_objCurrentRow = nullptr;
}
}
return blnRslt;
}
bool GLShaderTVArray::SetDataColor(int intCol, QRgb objColor)
{
bool blnRslt = false;
if (m_blnInitialized)
{
if ((intCol < m_intCols) && (intCol >= 0) && m_objCurrentRow)
{
m_objCurrentRow[intCol] = objColor;
blnRslt = true;
}
}
return blnRslt;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik