void Renderer::render()
{
QMutexLocker locker(&m_windowLock);
if (m_windows.isEmpty())
return;
HelloWindow *surface = m_windows.at(m_currentWindow);
QColor color = surface->color();
m_currentWindow = (m_currentWindow + 1) % m_windows.size();
if (!m_context->makeCurrent(surface))
return;
QSize viewSize = surface->size();
locker.unlock();
if (!m_initialized) {
initialize();
m_initialized = true;
}
QOpenGLFunctions *f = m_context->functions();
f->glViewport(0, 0, viewSize.width() * surface->devicePixelRatio(), viewSize.height() * surface->devicePixelRatio());
f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
f->glClearColor(m_backgroundColor.redF(), m_backgroundColor.greenF(), m_backgroundColor.blueF(), m_backgroundColor.alphaF());
f->glFrontFace(GL_CW);
f->glCullFace(GL_FRONT);
f->glEnable(GL_CULL_FACE);
f->glEnable(GL_DEPTH_TEST);
m_program->bind();
m_vbo.bind();
m_program->enableAttributeArray(vertexAttr);
m_program->enableAttributeArray(normalAttr);
m_program->setAttributeBuffer(vertexAttr, GL_FLOAT, 0, 3);
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
m_program->setAttributeBuffer(normalAttr, GL_FLOAT, verticesSize, 3);
QMatrix4x4 modelview;
modelview.rotate(m_fAngle, 0.0f, 1.0f, 0.0f);
modelview.rotate(m_fAngle, 1.0f, 0.0f, 0.0f);
modelview.rotate(m_fAngle, 0.0f, 0.0f, 1.0f);
modelview.translate(0.0f, -0.2f, 0.0f);
m_program->setUniformValue(matrixUniform, modelview);
m_program->setUniformValue(colorUniform, color);
m_context->functions()->glDrawArrays(GL_TRIANGLES, 0, vertices.size());
m_context->swapBuffers(surface);
m_fAngle += 1.0f;
QTimer::singleShot(0, this, SLOT(render()));
}
void QtRenderer::initialize()
{
QOpenGLShader *vshader = new QOpenGLShader(QOpenGLShader::Vertex, this);
vshader->compileSourceCode(
"attribute highp vec4 vertex;"
"attribute mediump vec3 normal;"
"uniform mediump mat4 matrix;"
"uniform lowp vec4 sourceColor;"
"varying mediump vec4 color;"
"void main(void)"
"{"
" vec3 toLight = normalize(vec3(0.0, 0.3, 1.0));"
" float angle = max(dot(normal, toLight), 0.0);"
" vec3 col = sourceColor.rgb;"
" color = vec4(col * 0.2 + col * 0.8 * angle, 1.0);"
" color = clamp(color, 0.0, 1.0);"
" gl_Position = matrix * vertex;"
"}");
QOpenGLShader *fshader = new QOpenGLShader(QOpenGLShader::Fragment, this);
fshader->compileSourceCode(
"varying mediump vec4 color;"
"void main(void)"
"{"
" gl_FragColor = color;"
"}");
m_program = new QOpenGLShaderProgram(this);
m_program->addShader(vshader);
m_program->addShader(fshader);
m_program->link();
m_program->bind();
vertexAttr = m_program->attributeLocation("vertex");
normalAttr = m_program->attributeLocation("normal");
matrixUniform = m_program->uniformLocation("matrix");
colorUniform = m_program->uniformLocation("sourceColor");
m_fAngle = 0;
createGeometry();
m_vbo.create();
m_vbo.bind();
const int verticesSize = vertices.count() * 3 * sizeof(GLfloat);
m_vbo.allocate(verticesSize * 2);
m_vbo.write(0, vertices.constData(), verticesSize);
m_vbo.write(verticesSize, normals.constData(), verticesSize);
QOpenGLFunctions *f = m_context->functions();
f->glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
f->glFrontFace(GL_CW);
f->glCullFace(GL_FRONT);
f->glEnable(GL_CULL_FACE);
f->glEnable(GL_DEPTH_TEST);
m_program->enableAttributeArray(vertexAttr);
m_program->enableAttributeArray(normalAttr);
m_program->setAttributeBuffer(vertexAttr, GL_FLOAT, 0, 3);
m_program->setAttributeBuffer(normalAttr, GL_FLOAT, verticesSize, 3);
}
void QGLWidgetGLPaintDevice::beginPaint()
{
QGLPaintDevice::beginPaint();
QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
if (!glWidget->d_func()->disable_clear_on_painter_begin && glWidget->autoFillBackground()) {
if (glWidget->testAttribute(Qt::WA_TranslucentBackground))
funcs->glClearColor(0.0, 0.0, 0.0, 0.0);
else {
const QColor &c = glWidget->palette().brush(glWidget->backgroundRole()).color();
float alpha = c.alphaF();
funcs->glClearColor(c.redF() * alpha, c.greenF() * alpha, c.blueF() * alpha, alpha);
}
if (context()->d_func()->workaround_needsFullClearOnEveryFrame)
funcs->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
else
funcs->glClear(GL_COLOR_BUFFER_BIT);
}
}
void Renderer::render()
{
QMutexLocker locker(&m_windowLock);
if (m_windows.isEmpty())
return;
HelloWindow *surface = m_windows.at(m_currentWindow);
QColor color = surface->color();
m_currentWindow = (m_currentWindow + 1) % m_windows.size();
if (!m_context->makeCurrent(surface))
return;
QSize viewSize = surface->size();
locker.unlock();
if (!m_initialized) {
initialize();
m_initialized = true;
}
QOpenGLFunctions *f = m_context->functions();
f->glViewport(0, 0, viewSize.width() * surface->devicePixelRatio(), viewSize.height() * surface->devicePixelRatio());
f->glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
f->glFrontFace(GL_CW);
f->glCullFace(GL_FRONT);
f->glEnable(GL_CULL_FACE);
f->glEnable(GL_DEPTH_TEST);
QMatrix4x4 modelview;
modelview.rotate(m_fAngle, 0.0f, 1.0f, 0.0f);
modelview.rotate(m_fAngle, 1.0f, 0.0f, 0.0f);
modelview.rotate(m_fAngle, 0.0f, 0.0f, 1.0f);
modelview.translate(0.0f, -0.2f, 0.0f);
m_program->bind();
m_program->setUniformValue(matrixUniform, modelview);
m_program->setUniformValue(colorUniform, color);
paintQtLogo();
m_program->release();
f->glDisable(GL_DEPTH_TEST);
f->glDisable(GL_CULL_FACE);
m_context->swapBuffers(surface);
m_fAngle += 1.0f;
QTimer::singleShot(0, this, SLOT(render()));
}
void exposeEvent(QExposeEvent *)
{
if (!isExposed())
return;
if (!gl) {
gl = new QOpenGLContext();
gl->setFormat(requestedFormat());
gl->create();
}
gl->makeCurrent(this);
QOpenGLShaderProgram prog;
prog.addShaderFromSourceCode(QOpenGLShader::Vertex,
"attribute highp vec4 a_Pos;"
"attribute lowp vec4 a_Color;"
"varying lowp vec4 v_Color;"
"void main() {"
" gl_Position = a_Pos;"
" v_Color = a_Color;"
"}");
prog.addShaderFromSourceCode(QOpenGLShader::Fragment,
"varying lowp vec4 v_Color;"
"void main() {"
" gl_FragColor = v_Color;"
"}");
prog.bind();
QOpenGLFunctions *functions = gl->functions();
functions->glClearColor(0, 0, 0, 0);
functions->glClear(GL_COLOR_BUFFER_BIT);
functions->glViewport(0, 0, width(), height());
prog.enableAttributeArray("a_Pos");
prog.enableAttributeArray("a_Color");
float coords[] = { -0.7f, 0.7f,
0.8f, 0.8f,
-0.8f, -0.8f,
0.7f, -0.7f };
float colors[] = { 1, 0, 0, 1,
0, 1, 0, 1,
0, 0, 1, 1,
0, 0, 0, 0 };
prog.setAttributeArray("a_Pos", GL_FLOAT, coords, 2, 0);
prog.setAttributeArray("a_Color", GL_FLOAT, colors, 4, 0);
functions->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
prog.disableAttributeArray("a_Pos");
prog.disableAttributeArray("a_Color");
gl->swapBuffers(this);
}
void
WebView::CreateGLContext() {
QOpenGLContext* context = window_->GLContext();
context->makeCurrent(window_);
static bool firstClearDone = false;
if (!firstClearDone) {
QOpenGLFunctions* functions = context->functions();
Q_ASSERT(functions);
functions->glClearColor(1.0, 1.0, 1.0, 0.0);
functions->glClear(GL_COLOR_BUFFER_BIT);
context->swapBuffers(window_);
firstClearDone = true;
}
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
f->glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
shaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shader/lightingVertexShader.vsh");
shaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shader/lightingFragmentShader.fsh");
shaderProgram.link();
coloringShaderProgram.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shader/coloringVertexShader.vsh");
coloringShaderProgram.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shader/coloringFragmentShader.fsh");
coloringShaderProgram.link();
cout << "OpenGL Version : " << glGetString(GL_VERSION) << endl;
}
void QOpenGLTextureBlitWindow::render()
{
m_context->makeCurrent(this);
QRect viewport(0,0,dWidth(),dHeight());
QOpenGLFunctions *functions = m_context->functions();
functions->glViewport(0,0,dWidth(), dHeight());
functions->glClearColor(0.f, .6f, .0f, 0.f);
functions->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
QOpenGLTexture texture(m_image);
texture.setWrapMode(QOpenGLTexture::ClampToEdge);
texture.create();
QOpenGLTexture texture_mirrored(m_image_mirrord);
texture_mirrored.setWrapMode(QOpenGLTexture::ClampToEdge);
texture_mirrored.create();
QRectF topLeftOriginTopLeft(QPointF(0,0), QPointF(dWidth()/2.0, dHeight()/2.0));
QRectF topRightOriginTopLeft(QPointF(dWidth()/2.0,0), QPointF(dWidth(), dHeight()/2.0));
QRectF bottomLeftOriginTopLeft(QPointF(0, dHeight()/2.0), QPointF(dWidth() /2.0, dHeight()));
QRectF bottomRightOriginTopLeft(QPoint(dWidth()/2.0, dHeight()/2.0), QPointF(dWidth(), dHeight()));
QRectF topLeftOriginBottomLeft = bottomLeftOriginTopLeft; Q_UNUSED(topLeftOriginBottomLeft);
QRectF topRightOriginBottomLeft = bottomRightOriginTopLeft; Q_UNUSED(topRightOriginBottomLeft);
QRectF bottomLeftOriginBottomLeft = topLeftOriginTopLeft;
QRectF bottomRightOriginBottomLeft = topRightOriginTopLeft;
QOpenGLTextureBlitter::Origin topLeftOrigin = QOpenGLTextureBlitter::OriginTopLeft;
QOpenGLTextureBlitter::Origin bottomLeftOrigin = QOpenGLTextureBlitter::OriginBottomLeft;
QMatrix4x4 topRightOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(topRightOriginTopLeft, viewport);
QMatrix4x4 bottomLeftOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(bottomLeftOriginTopLeft, viewport);
QMatrix4x4 bottomRightOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(bottomRightOriginTopLeft, viewport);
QMatrix3x3 texTopLeftOriginTopLeft = QOpenGLTextureBlitter::sourceTransform(topLeftOriginTopLeft, m_image.size(), topLeftOrigin);
QMatrix3x3 texTopRightOriginBottomLeft = QOpenGLTextureBlitter::sourceTransform(topRightOriginBottomLeft, m_image.size(), bottomLeftOrigin);
QMatrix3x3 texBottomLeftOriginBottomLeft = QOpenGLTextureBlitter::sourceTransform(bottomLeftOriginBottomLeft, m_image.size(), bottomLeftOrigin);
QMatrix3x3 texBottomRightOriginBottomLeft = QOpenGLTextureBlitter::sourceTransform(bottomRightOriginBottomLeft, m_image.size(), bottomLeftOrigin);
QSizeF subSize(topLeftOriginTopLeft.width()/2, topLeftOriginTopLeft.height()/2);
QRectF subTopLeftOriginTopLeft(topLeftOriginTopLeft.topLeft(), subSize);
QRectF subTopRightOriginTopLeft(QPointF(topLeftOriginTopLeft.topLeft().x() + topLeftOriginTopLeft.width() / 2,
topLeftOriginTopLeft.topLeft().y()), subSize);
QRectF subBottomLeftOriginTopLeft(QPointF(topLeftOriginTopLeft.topLeft().x(),
topLeftOriginTopLeft.topLeft().y() + topLeftOriginTopLeft.height() / 2), subSize);
QRectF subBottomRightOriginTopLeft(QPointF(topLeftOriginTopLeft.topLeft().x() + topLeftOriginTopLeft.width() / 2,
topLeftOriginTopLeft.topLeft().y() + topLeftOriginTopLeft.height() / 2), subSize);
QMatrix4x4 subTopLeftOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(subTopLeftOriginTopLeft, viewport);
QMatrix4x4 subTopRightOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(subTopRightOriginTopLeft, viewport);
QMatrix4x4 subBottomLeftOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(subBottomLeftOriginTopLeft, viewport);
QMatrix4x4 subBottomRightOriginTopLeftVertex = QOpenGLTextureBlitter::targetTransform(subBottomRightOriginTopLeft, viewport);
m_blitter.bind();
m_blitter.blit(texture_mirrored.textureId(), subTopLeftOriginTopLeftVertex, texBottomRightOriginBottomLeft);
m_blitter.blit(texture_mirrored.textureId(), subTopRightOriginTopLeftVertex, texBottomLeftOriginBottomLeft);
m_blitter.blit(texture.textureId(), subBottomLeftOriginTopLeftVertex, texTopRightOriginBottomLeft);
m_blitter.blit(texture.textureId(), subBottomRightOriginTopLeftVertex, texTopLeftOriginTopLeft);
m_blitter.blit(texture.textureId(), topRightOriginTopLeftVertex, topLeftOrigin);
m_blitter.blit(texture_mirrored.textureId(), bottomLeftOriginTopLeftVertex, topLeftOrigin);
m_blitter.setSwizzleRB(true);
m_blitter.blit(texture.textureId(), bottomRightOriginTopLeftVertex, texTopLeftOriginTopLeft);
m_blitter.setSwizzleRB(false);
m_blitter.release();
if (m_blitter.supportsExternalOESTarget()) {
// Cannot do much testing here, just verify that bind and release work, meaning that the program is present.
m_blitter.bind(0x8D65);
m_blitter.release();
}
m_context->swapBuffers(this);
}