1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OpenGL: add support for compute shaders in GLES 3.1

Browse Source 
OpenGL ES 3.1 introduces compute shaders. This patch enables them also
in QOpenGLShader/QOpenGLShaderProgram.
A GL/GLES example using QOpenGLShaderProgram for compute shaders is also
included.

Change-Id: I3951a302d7c2b096548f829b9b4578b5a525c453
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
This commit is contained in:
Paolo Angelelli 2016-02-11 09:44:14 +01:00
parent abbc5ecc5e
commit a6b8b03f86
8 changed files with 786 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
examples/opengl/computegles31/Qt-logo-medium.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

9
examples/opengl/computegles31/computegles31.pro Normal file
View File

@ -0,0 +1,9 @@
HEADERS = $$PWD/glwindow.h
SOURCES = $$PWD/glwindow.cpp \
$$PWD/main.cpp
RESOURCES += computegles31.qrc
target.path = $$[QT_INSTALL_EXAMPLES]/opengl/computegles31
INSTALLS += target

5
examples/opengl/computegles31/computegles31.qrc Normal file
View File

@ -0,0 +1,5 @@
<RCC>
<qresource prefix="/">
<file>Qt-logo-medium.png</file>
</qresource>
</RCC>

423
examples/opengl/computegles31/glwindow.cpp Normal file
View File

@ -0,0 +1,423 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "glwindow.h"
#include <QImage>
#include <QOpenGLShaderProgram>
#include <QOpenGLContext>
#include <QOpenGLFunctions>
#include <QOpenGLExtraFunctions>
//#include <QtGui/qopenglext.h>
#include <QtGui/qopengl.h>
#include <QDebug>
#include <QTimer>
#include <math.h>
#ifndef GL_READ_WRITE
#define GL_READ_WRITE 0x88BA
#endif
#ifndef GL_RGBA8
#define GL_RGBA8 0x8058
#endif
#ifndef GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020
#endif
GLWindow::GLWindow()
: m_texImageInput(0),
m_texImageTmp(0),
m_texImageProcessed(0),
m_shaderDisplay(0),
m_shaderComputeV(0),
m_shaderComputeH(0),
m_blurRadius(0.0f),
m_animate(true)
{
const float animationStart = 0.0;
const float animationEnd = 10.0;
const float animationLength = 1000;
m_animationGroup = new QSequentialAnimationGroup(this);
m_animationGroup->setLoopCount(-1);
m_animationForward = new QPropertyAnimation(this, QByteArrayLiteral("blurRadius"));
m_animationForward->setStartValue(animationStart);
m_animationForward->setEndValue(animationEnd);
m_animationForward->setDuration(animationLength);
m_animationGroup->addAnimation(m_animationForward);
m_animationBackward = new QPropertyAnimation(this, QByteArrayLiteral("blurRadius"));
m_animationBackward->setStartValue(animationEnd);
m_animationBackward->setEndValue(animationStart);
m_animationBackward->setDuration(animationLength);
m_animationGroup->addAnimation(m_animationBackward);
m_animationGroup->start();
}
GLWindow::~GLWindow()
{
makeCurrent();
delete m_texImageInput;
delete m_texImageProcessed;
delete m_texImageTmp;
delete m_shaderDisplay;
delete m_shaderComputeH;
delete m_shaderComputeV;
delete m_animationGroup;
delete m_animationForward;
delete m_animationBackward;
}
void GLWindow::setBlurRadius(float blurRadius)
{
int radius = int(blurRadius);
if (radius != m_blurRadius) {
m_blurRadius = radius;
update();
}
}
void GLWindow::setAnimating(bool animate)
{
m_animate = animate;
if (animate)
m_animationGroup->start();
else
m_animationGroup->stop();
}
void GLWindow::keyPressEvent(QKeyEvent *e)
{
if (e->key() == Qt::Key_Space) { // pause
setAnimating(!m_animate);
}
update();
}
static const char *vsDisplaySource =
"const vec4 vertices[4] = vec4[4] (\n"
" vec4( -1.0, 1.0, 0.0, 1.0),\n"
" vec4( -1.0, -1.0, 0.0, 1.0),\n"
" vec4( 1.0, 1.0, 0.0, 1.0),\n"
" vec4( 1.0, -1.0, 0.0, 1.0)\n"
");\n"
"const vec2 texCoords[4] = vec2[4] (\n"
" vec2( 0.0, 1.0),\n"
" vec2( 0.0, 0.0),\n"
" vec2( 1.0, 1.0),\n"
" vec2( 1.0, 0.0)\n"
");\n"
"out vec2 texCoord;\n"
"uniform mat4 matProjection;\n"
"uniform vec2 imageRatio;\n"
"void main() {\n"
" gl_Position = matProjection * ( vertices[gl_VertexID] * vec4(imageRatio,0,1) );\n"
" texCoord = texCoords[gl_VertexID];\n"
"}\n";
static const char *fsDisplaySource =
"in lowp vec2 texCoord; \n"
"uniform sampler2D samImage; \n"
"layout(location = 0) out lowp vec4 color;\n"
"void main() {\n"
" lowp vec4 texColor = texture(samImage,texCoord);\n"
" color = vec4(texColor.rgb, 1.0);\n"
"}\n";
static const char *csComputeSourceV =
//"#extension GL_EXT_gpu_shader5 : require \n"
"#define COMPUTEPATCHSIZE 32 \n"
"#define IMGFMT rgba8 \n"
"layout (local_size_x = COMPUTEPATCHSIZE, local_size_y = COMPUTEPATCHSIZE) in;\n"
"layout(binding=0, IMGFMT) uniform highp image2D inputImage; // Use a sampler to improve performance \n"
"layout(binding=1, IMGFMT) uniform highp image2D resultImage;\n"
"uniform int radius;\n"
"const float cutoff = 2.2;\n"
"float sigma = clamp(float(radius) / cutoff,0.02,100.0);\n" // Const initialization with dynamically uniform expressions doesn't work in GLES
"float expFactor = 1.0 / (2.0 * sigma * sigma);\n" // Same here
"float gaussian(float distance) {\n"
" return exp( -(distance * distance) * expFactor);\n"
"}\n"
"void main() {\n"
" ivec2 imgSize = imageSize(resultImage);\n"
" int x = int(gl_GlobalInvocationID.x);\n"
" int y = int(gl_GlobalInvocationID.y);\n"
" if ( (x >= imgSize.x) || (y >= imgSize.y) ) return;\n"
" vec4 sumPixels = vec4(0.0);\n"
" float sumWeights = 0.0;\n"
" int left = clamp(x - radius, 0, imgSize.x - 1);\n"
" int right = clamp(x + radius, 0, imgSize.x - 1);\n"
" int top = clamp(y - radius, 0, imgSize.y - 1);\n"
" int bottom = clamp(y + radius, 0, imgSize.y - 1);\n"
" for (int iY = top; iY <= bottom; iY++) {\n"
" float dy = float(abs(iY - y));\n"
" vec4 imgValue = imageLoad(inputImage, ivec2(x,iY));\n"
" float weight = gaussian(dy);\n"
" sumWeights += weight;\n"
" sumPixels += (imgValue * weight);\n"
" }\n"
" sumPixels /= sumWeights;\n"
" imageStore(resultImage, ivec2(x,y), sumPixels);"
"}\n";
static const char *csComputeSourceH =
//"#extension GL_EXT_gpu_shader5 : require \n"
"#define COMPUTEPATCHSIZE 32 \n"
"#define IMGFMT rgba8 \n"
"layout (local_size_x = COMPUTEPATCHSIZE, local_size_y = COMPUTEPATCHSIZE) in;\n"
"layout(binding=0, IMGFMT) uniform highp image2D inputImage; // Use a sampler to improve performance \n"
"layout(binding=1, IMGFMT) uniform highp image2D resultImage;\n"
"uniform int radius;\n"
"const float cutoff = 2.2;\n"
"float sigma = clamp(float(radius) / cutoff,0.02,100.0);\n"
"float expFactor = 1.0 / (2.0 * sigma * sigma);\n"
"float gaussian(float distance) {\n"
" return exp( -(distance * distance) * expFactor);\n"
"}\n"
"void main() {\n"
" ivec2 imgSize = imageSize(resultImage);\n"
" int x = int(gl_GlobalInvocationID.x);\n"
" int y = int(gl_GlobalInvocationID.y);\n"
" if ( (x >= imgSize.x) || (y >= imgSize.y) ) return;\n"
" vec4 sumPixels = vec4(0.0);\n"
" float sumWeights = 0.0;\n"
" int left = clamp(x - radius, 0, imgSize.x - 1);\n"
" int right = clamp(x + radius, 0, imgSize.x - 1);\n"
" int top = clamp(y - radius, 0, imgSize.y - 1);\n"
" int bottom = clamp(y + radius, 0, imgSize.y - 1);\n"
" for (int iX = left; iX <= right; iX++) {\n"
" float dx = float(abs(iX - x));\n"
" vec4 imgValue = imageLoad(inputImage, ivec2(iX,y));\n"
" float weight = gaussian(dx);\n"
" sumWeights += weight;\n"
" sumPixels += (imgValue * weight);\n"
" }\n"
" sumPixels /= sumWeights;\n"
" imageStore(resultImage, ivec2(x,y), sumPixels);"
"}\n";
QByteArray versionedShaderCode(const char *src)
{
QByteArray versionedSrc;
if (QOpenGLContext::currentContext()->isOpenGLES())
versionedSrc.append(QByteArrayLiteral("#version 310 es\n"));
else
versionedSrc.append(QByteArrayLiteral("#version 430\n"));
versionedSrc.append(src);
return versionedSrc;
}
void computeProjection(int winWidth, int winHeight, int imgWidth, int imgHeight, QMatrix4x4 &outProjection, QSizeF &outQuadSize)
{
float ratioImg = float(imgWidth) / float(imgHeight);
float ratioCanvas = float(winWidth) / float(winHeight);
float correction = ratioImg / ratioCanvas;
float rescaleFactor = 1.0f;
float quadWidth = 1.0f;
float quadHeight = 1.0f;
if (correction < 1.0f) // canvas larger than image -- height = 1.0, vertical black bands
{
quadHeight = 1.0f;
quadWidth = 1.0f * ratioImg;
rescaleFactor = ratioCanvas;
correction = 1.0f / rescaleFactor;
}
else // image larger than canvas -- width = 1.0, horizontal black bands
{
quadWidth = 1.0f;
quadHeight = 1.0f / ratioImg;
correction = 1.0f / ratioCanvas;
}
const float frustumWidth = 1.0f * rescaleFactor;
const float frustumHeight = 1.0f * rescaleFactor * correction;
outProjection = QMatrix4x4();
outProjection.ortho(
-frustumWidth,
frustumWidth,
-frustumHeight,
frustumHeight,
-1.0f,
1.0f);
outQuadSize = QSizeF(quadWidth,quadHeight);
}
void GLWindow::initializeGL()
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
qDebug() << "Got a "
<< ctx->format().majorVersion()
<< "."
<< ctx->format().minorVersion()
<< ((ctx->format().renderableType() == QSurfaceFormat::OpenGLES) ? (" GLES") : (" GL"))
<< " context";
//QOpenGLFunctions *f = ctx->functions();
if (m_texImageInput) {
delete m_texImageInput;
m_texImageInput = 0;
}
QImage img(":/Qt-logo-medium.png");
Q_ASSERT(!img.isNull());
m_texImageInput = new QOpenGLTexture(img.convertToFormat(QImage::Format_RGBA8888).mirrored());
if (m_texImageTmp) {
delete m_texImageTmp;
m_texImageTmp = 0;
}
m_texImageTmp = new QOpenGLTexture(QOpenGLTexture::Target2D);
m_texImageTmp->setFormat(m_texImageInput->format());
m_texImageTmp->setSize(m_texImageInput->width(),m_texImageInput->height());
m_texImageTmp->allocateStorage(QOpenGLTexture::RGBA,QOpenGLTexture::UInt8); // WTF?
if (m_texImageProcessed) {
delete m_texImageProcessed;
m_texImageProcessed = 0;
}
m_texImageProcessed = new QOpenGLTexture(QOpenGLTexture::Target2D);
m_texImageProcessed->setFormat(m_texImageInput->format());
m_texImageProcessed->setSize(m_texImageInput->width(),m_texImageInput->height());
m_texImageProcessed->allocateStorage(QOpenGLTexture::RGBA,QOpenGLTexture::UInt8);
m_texImageProcessed->setMagnificationFilter(QOpenGLTexture::Linear);
m_texImageProcessed->setMinificationFilter(QOpenGLTexture::Linear);
m_texImageProcessed->setWrapMode(QOpenGLTexture::ClampToEdge);
if (m_shaderDisplay) {
delete m_shaderDisplay;
m_shaderDisplay = 0;
}
m_shaderDisplay = new QOpenGLShaderProgram;
// Prepend the correct version directive to the sources. The rest is the
// same, thanks to the common GLSL syntax.
m_shaderDisplay->addShaderFromSourceCode(QOpenGLShader::Vertex, versionedShaderCode(vsDisplaySource));
m_shaderDisplay->addShaderFromSourceCode(QOpenGLShader::Fragment, versionedShaderCode(fsDisplaySource));
m_shaderDisplay->link();
if (m_shaderComputeV) {
delete m_shaderComputeV;
m_shaderComputeV = 0;
}
m_shaderComputeV = new QOpenGLShaderProgram;
m_shaderComputeV->addShaderFromSourceCode(QOpenGLShader::Compute, versionedShaderCode(csComputeSourceV));
m_shaderComputeV->link();
if (m_shaderComputeH) {
delete m_shaderComputeH;
m_shaderComputeH = 0;
}
m_shaderComputeH = new QOpenGLShaderProgram;
m_shaderComputeH->addShaderFromSourceCode(QOpenGLShader::Compute, versionedShaderCode(csComputeSourceH));
m_shaderComputeH->link();
}
void GLWindow::resizeGL(int w, int h)
{
computeProjection(w,h,m_texImageInput->width(),m_texImageInput->height(),m_proj,m_quadSize);
}
QSize getWorkGroups(int workGroupSize, const QSize &imageSize)
{
int x = imageSize.width();
x = (x % workGroupSize) ? (x / workGroupSize) + 1 : (x / workGroupSize);
int y = imageSize.height();
y = (y % workGroupSize) ? (y / workGroupSize) + 1 : (y / workGroupSize);
return QSize(x,y);
}
void GLWindow::paintGL()
{
// Now use QOpenGLExtraFunctions instead of QOpenGLFunctions as we want to
// do more than what GL(ES) 2.0 offers.
QOpenGLExtraFunctions *f = QOpenGLContext::currentContext()->extraFunctions();
// Process input image
QSize workGroups = getWorkGroups( 32, QSize(m_texImageInput->width(), m_texImageInput->height()));
// Pass 1
f->glBindImageTexture(0, m_texImageInput->textureId(), 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
f->glBindImageTexture(1, m_texImageTmp->textureId(), 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
m_shaderComputeV->bind();
m_shaderComputeV->setUniformValue("radius",m_blurRadius);
f->glDispatchCompute(workGroups.width(),workGroups.height(),1);
f->glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
m_shaderComputeV->release();
// Pass 2
f->glBindImageTexture(0, m_texImageTmp->textureId(), 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
f->glBindImageTexture(1, m_texImageProcessed->textureId(), 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
m_shaderComputeH->bind();
m_shaderComputeH->setUniformValue("radius",m_blurRadius);
f->glDispatchCompute(workGroups.width(),workGroups.height(),1);
f->glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
m_shaderComputeH->release();
// Compute cleanup
f->glBindImageTexture(0, 0, 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
f->glBindImageTexture(1, 0, 0, 0, 0, GL_READ_WRITE, GL_RGBA8);
// Display processed image
f->glClearColor(0, 0, 0, 1);
f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_texImageProcessed->bind(GL_TEXTURE0);
m_shaderDisplay->bind();
m_shaderDisplay->setUniformValue("matProjection",m_proj);
m_shaderDisplay->setUniformValue("imageRatio",m_quadSize);
m_shaderDisplay->setUniformValue("samImage",0);
f->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_shaderDisplay->release();
m_texImageProcessed->release(GL_TEXTURE0);
}

99
examples/opengl/computegles31/glwindow.h Normal file
View File

@ -0,0 +1,99 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef GLWIDGET_H
#define GLWIDGET_H
#include <QOpenGLWindow>
#include <QOpenGLTexture>
#include <QMatrix4x4>
#include <QVector3D>
#include <QKeyEvent>
#include <QPropertyAnimation>
#include <QSequentialAnimationGroup>
#include <QRectF>
QT_BEGIN_NAMESPACE
class QOpenGLTexture;
class QOpenGLShaderProgram;
class QOpenGLBuffer;
class QOpenGLVertexArrayObject;
QT_END_NAMESPACE
class GLWindow : public QOpenGLWindow
{
Q_OBJECT
Q_PROPERTY(float blurRadius READ blurRadius WRITE setBlurRadius)
public:
GLWindow();
~GLWindow();
void initializeGL();
void resizeGL(int w, int h);
void paintGL();
float blurRadius() const { return m_blurRadius; }
void setBlurRadius(float blurRadius);
protected:
void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
void setAnimating(bool animate);
private:
QPropertyAnimation *m_animationForward;
QPropertyAnimation *m_animationBackward;
QSequentialAnimationGroup *m_animationGroup;
QOpenGLTexture *m_texImageInput;
QOpenGLTexture *m_texImageTmp;
QOpenGLTexture *m_texImageProcessed;
QOpenGLShaderProgram *m_shaderDisplay;
QOpenGLShaderProgram *m_shaderComputeV;
QOpenGLShaderProgram *m_shaderComputeH;
QMatrix4x4 m_proj;
QSizeF m_quadSize;
int m_blurRadius;
bool m_animate;
};
#endif

118
examples/opengl/computegles31/main.cpp Normal file
View File

@ -0,0 +1,118 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the examples of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of The Qt Company Ltd nor the names of its
** contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QGuiApplication>
#include <QSurfaceFormat>
#include <QOffscreenSurface>
#include <QOpenGLContext>
#include <QDebug>
#include <QPair>
#include "glwindow.h"
bool OGLSupports(int major, int minor, bool gles = false)
{
QOpenGLContext ctx;
QSurfaceFormat fmt;
fmt.setVersion(major, minor);
if (gles)
fmt.setRenderableType(QSurfaceFormat::OpenGLES);
else
fmt.setRenderableType(QSurfaceFormat::OpenGL);
ctx.setFormat(fmt);
ctx.create();
if (!ctx.isValid())
return false;
int ctxMajor = ctx.format().majorVersion();
int ctxMinor = ctx.format().minorVersion();
bool isGles = (ctx.format().renderableType() == QSurfaceFormat::OpenGLES);
if (isGles != gles) return false;
if (ctxMajor < major) return false;
if (ctxMajor == major && ctxMinor < minor)
return false;
return true;
}
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
qDebug() << "Support for GL 2.0 "<<( OGLSupports(2,0) ? "yes" : "no");
qDebug() << "Support for GL 2.1 "<<( OGLSupports(2,1) ? "yes" : "no");
qDebug() << "Support for GL 3.0 "<<( OGLSupports(3,0) ? "yes" : "no");
qDebug() << "Support for GL 3.1 "<<( OGLSupports(3,1) ? "yes" : "no");
qDebug() << "Support for GL 3.2 "<<( OGLSupports(3,2) ? "yes" : "no");
qDebug() << "Support for GL 3.3 "<<( OGLSupports(3,3) ? "yes" : "no");
qDebug() << "Support for GL 4.0 "<<( OGLSupports(4,0) ? "yes" : "no");
qDebug() << "Support for GL 4.1 "<<( OGLSupports(4,1) ? "yes" : "no");
qDebug() << "Support for GL 4.2 "<<( OGLSupports(4,2) ? "yes" : "no");
qDebug() << "Support for GL 4.3 "<<( OGLSupports(4,3) ? "yes" : "no");
qDebug() << "Support for GL 4.4 "<<( OGLSupports(4,4) ? "yes" : "no");
qDebug() << "Support for GL 4.5 "<<( OGLSupports(4,5) ? "yes" : "no");
qDebug() << "Support for GLES 2.0 "<<( OGLSupports(2,0,true) ? "yes" : "no");
qDebug() << "Support for GLES 3.0 "<<( OGLSupports(3,0,true) ? "yes" : "no");
qDebug() << "Support for GLES 3.1 "<<( OGLSupports(3,1,true) ? "yes" : "no");
qDebug() << "Support for GLES 3.2 "<<( OGLSupports(3,2,true) ? "yes" : "no");
QSurfaceFormat fmt;
fmt.setDepthBufferSize(24);
// Request OpenGL 4.3 compatibility or OpenGL ES 3.1.
if (OGLSupports(4,3)) {
qDebug("Requesting 4.3 compatibility context");
fmt.setVersion(4, 3);
fmt.setRenderableType(QSurfaceFormat::OpenGL);
fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
} else if (OGLSupports(3,1,true)) {
qDebug("Requesting 3.1 GLES context");
fmt.setVersion(3, 1);
fmt.setRenderableType(QSurfaceFormat::OpenGLES);
} else {
qWarning("Error: This system does not support OpenGL Compute Shaders! Exiting.");
return -1;
}
QSurfaceFormat::setDefaultFormat(fmt);
GLWindow glWindow;
glWindow.showMaximized();
return app.exec();
}

3
examples/opengl/opengl.pro
View File

@ -14,7 +14,8 @@ qtHaveModule(widgets) {
qopenglwidget \
cube \
textures \
hellogles3
hellogles3 \
computegles31
}
EXAMPLE_FILES += \

221
src/gui/opengl/qopenglshaderprogram.cpp
View File

@ -162,6 +162,79 @@ QT_BEGIN_NAMESPACE
based on the core feature (requires OpenGL >= 4.3).
*/
// For GLES 3.1/3.2
#ifndef GL_GEOMETRY_SHADER
#define GL_GEOMETRY_SHADER 0x8DD9
#endif
#ifndef GL_TESS_CONTROL_SHADER
#define GL_TESS_CONTROL_SHADER 0x8E88
#endif
#ifndef GL_TESS_EVALUATION_SHADER
#define GL_TESS_EVALUATION_SHADER 0x8E87
#endif
#ifndef GL_COMPUTE_SHADER
#define GL_COMPUTE_SHADER 0x91B9
#endif
#ifndef GL_MAX_GEOMETRY_OUTPUT_VERTICES
#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
#endif
#ifndef GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS
#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
#endif
#ifndef GL_PATCH_VERTICES
#define GL_PATCH_VERTICES 0x8E72
#endif
#ifndef GL_PATCH_DEFAULT_OUTER_LEVEL
#define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74
#endif
#ifndef GL_PATCH_DEFAULT_INNER_LEVEL
#define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73
#endif
static inline bool isFormatGLES(const QSurfaceFormat &f)
{
return (f.renderableType() == QSurfaceFormat::OpenGLES);
}
static inline bool supportsGeometry(const QSurfaceFormat &f)
{
#ifndef QT_OPENGL_ES_2
if (!isFormatGLES(f))
return (f.version() >= qMakePair<int, int>(3, 2));
else
return false;
#else
Q_UNUSED(f);
return false;
#endif
}
static inline bool supportsCompute(const QSurfaceFormat &f)
{
#ifndef QT_OPENGL_ES_2
if (!isFormatGLES(f))
return (f.version() >= qMakePair<int, int>(4, 3));
else
return (f.version() >= qMakePair<int, int>(3, 1));
#else
return (f.version() >= qMakePair<int, int>(3, 1));
#endif
}
static inline bool supportsTessellation(const QSurfaceFormat &f)
{
#ifndef QT_OPENGL_ES_2
if (!isFormatGLES(f))
return (f.version() >= qMakePair<int, int>(4, 0));
else
return false;
#else
Q_UNUSED(f);
return false;
#endif
}
class QOpenGLShaderPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QOpenGLShader)
@ -171,22 +244,16 @@ public:
, shaderType(type)
, compiled(false)
, glfuncs(new QOpenGLFunctions(ctx))
#ifndef QT_OPENGL_ES_2
, supportsGeometryShaders(false)
, supportsTessellationShaders(false)
#endif
, supportsComputeShaders(false)
{
#ifndef QT_OPENGL_ES_2
if (!ctx->isOpenGLES()) {
QSurfaceFormat f = ctx->format();
// Geometry shaders require OpenGL >= 3.2
if (shaderType & QOpenGLShader::Geometry)
supportsGeometryShaders = (f.version() >= qMakePair<int, int>(3, 2));
else if (shaderType & (QOpenGLShader::TessellationControl | QOpenGLShader::TessellationEvaluation))
supportsTessellationShaders = (f.version() >= qMakePair<int, int>(4, 0));
}
#endif
if (shaderType & QOpenGLShader::Geometry)
supportsGeometryShaders = supportsGeometry(ctx->format());
else if (shaderType & (QOpenGLShader::TessellationControl | QOpenGLShader::TessellationEvaluation))
supportsTessellationShaders = supportsTessellation(ctx->format());
else if (shaderType & QOpenGLShader::Compute)
supportsComputeShaders = supportsCompute(ctx->format());
}
~QOpenGLShaderPrivate();
@ -197,13 +264,13 @@ public:
QOpenGLFunctions *glfuncs;
#ifndef QT_OPENGL_ES_2
// Support for geometry shaders
bool supportsGeometryShaders;
// Support for tessellation shaders
bool supportsTessellationShaders;
#endif
// Support for compute shaders
bool supportsComputeShaders;
bool create();
bool compile(QOpenGLShader *q);
@ -232,21 +299,15 @@ bool QOpenGLShaderPrivate::create()
GLuint shader;
if (shaderType == QOpenGLShader::Vertex) {
shader = glfuncs->glCreateShader(GL_VERTEX_SHADER);
#if defined(QT_OPENGL_3_2)
} else if (shaderType == QOpenGLShader::Geometry && supportsGeometryShaders) {
shader = glfuncs->glCreateShader(GL_GEOMETRY_SHADER);
#endif
#if defined(QT_OPENGL_4)
} else if (shaderType == QOpenGLShader::TessellationControl && supportsTessellationShaders) {
shader = glfuncs->glCreateShader(GL_TESS_CONTROL_SHADER);
} else if (shaderType == QOpenGLShader::TessellationEvaluation && supportsTessellationShaders) {
shader = glfuncs->glCreateShader(GL_TESS_EVALUATION_SHADER);
#endif
#if defined(QT_OPENGL_4_3)
} else if (shaderType == QOpenGLShader::Compute) {
} else if (shaderType == QOpenGLShader::Compute && supportsComputeShaders) {
shader = glfuncs->glCreateShader(GL_COMPUTE_SHADER);
#endif
} else {
} else if (shaderType == QOpenGLShader::Fragment) {
shader = glfuncs->glCreateShader(GL_FRAGMENT_SHADER);
}
if (!shader) {
@ -3209,10 +3270,8 @@ void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4
int QOpenGLShaderProgram::maxGeometryOutputVertices() const
{
GLint n = 0;
#if defined(QT_OPENGL_3_2)
Q_D(const QOpenGLShaderProgram);
d->glfuncs->glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &n);
#endif
return n;
}
@ -3236,7 +3295,7 @@ int QOpenGLShaderProgram::maxGeometryOutputVertices() const
*/
void QOpenGLShaderProgram::setPatchVertexCount(int count)
{
#if defined(QT_OPENGL_4)
#ifndef QT_OPENGL_ES_2
Q_D(QOpenGLShaderProgram);
if (d->tessellationFuncs)
d->tessellationFuncs->glPatchParameteri(GL_PATCH_VERTICES, count);
@ -3255,13 +3314,15 @@ void QOpenGLShaderProgram::setPatchVertexCount(int count)
*/
int QOpenGLShaderProgram::patchVertexCount() const
{
#ifndef QT_OPENGL_ES_2
int patchVertices = 0;
#if defined(QT_OPENGL_4)
Q_D(const QOpenGLShaderProgram);
if (d->tessellationFuncs)
d->tessellationFuncs->glGetIntegerv(GL_PATCH_VERTICES, &patchVertices);
#endif
return patchVertices;
#else
return 0;
#endif
}
/*!
@ -3283,21 +3344,21 @@ int QOpenGLShaderProgram::patchVertexCount() const
*/
void QOpenGLShaderProgram::setDefaultOuterTessellationLevels(const QVector<float> &levels)
{
#if defined(QT_OPENGL_4)
QVector<float> tessLevels = levels;
// Ensure we have the required 4 outer tessellation levels
// Use default of 1 for missing entries (same as spec)
const int argCount = 4;
if (tessLevels.size() < argCount) {
tessLevels.reserve(argCount);
for (int i = tessLevels.size(); i < argCount; ++i)
tessLevels.append(1.0f);
}
#ifndef QT_OPENGL_ES_2
Q_D(QOpenGLShaderProgram);
if (d->tessellationFuncs)
if (d->tessellationFuncs) {
QVector<float> tessLevels = levels;
// Ensure we have the required 4 outer tessellation levels
// Use default of 1 for missing entries (same as spec)
const int argCount = 4;
if (tessLevels.size() < argCount) {
tessLevels.reserve(argCount);
for (int i = tessLevels.size(); i < argCount; ++i)
tessLevels.append(1.0f);
}
d->tessellationFuncs->glPatchParameterfv(GL_PATCH_DEFAULT_OUTER_LEVEL, tessLevels.data());
}
#else
Q_UNUSED(levels);
#endif
@ -3320,13 +3381,15 @@ void QOpenGLShaderProgram::setDefaultOuterTessellationLevels(const QVector<float
*/
QVector<float> QOpenGLShaderProgram::defaultOuterTessellationLevels() const
{
#ifndef QT_OPENGL_ES_2
QVector<float> tessLevels(4, 1.0f);
#if defined(QT_OPENGL_4)
Q_D(const QOpenGLShaderProgram);
if (d->tessellationFuncs)
d->tessellationFuncs->glGetFloatv(GL_PATCH_DEFAULT_OUTER_LEVEL, tessLevels.data());
#endif
return tessLevels;
#else
return QVector<float>();
#endif
}
/*!
@ -3348,21 +3411,21 @@ QVector<float> QOpenGLShaderProgram::defaultOuterTessellationLevels() const
*/
void QOpenGLShaderProgram::setDefaultInnerTessellationLevels(const QVector<float> &levels)
{
#if defined(QT_OPENGL_4)
QVector<float> tessLevels = levels;
// Ensure we have the required 2 inner tessellation levels
// Use default of 1 for missing entries (same as spec)
const int argCount = 2;
if (tessLevels.size() < argCount) {
tessLevels.reserve(argCount);
for (int i = tessLevels.size(); i < argCount; ++i)
tessLevels.append(1.0f);
}
#ifndef QT_OPENGL_ES_2
Q_D(QOpenGLShaderProgram);
if (d->tessellationFuncs)
if (d->tessellationFuncs) {
QVector<float> tessLevels = levels;
// Ensure we have the required 2 inner tessellation levels
// Use default of 1 for missing entries (same as spec)
const int argCount = 2;
if (tessLevels.size() < argCount) {
tessLevels.reserve(argCount);
for (int i = tessLevels.size(); i < argCount; ++i)
tessLevels.append(1.0f);
}
d->tessellationFuncs->glPatchParameterfv(GL_PATCH_DEFAULT_INNER_LEVEL, tessLevels.data());
}
#else
Q_UNUSED(levels);
#endif
@ -3385,13 +3448,15 @@ void QOpenGLShaderProgram::setDefaultInnerTessellationLevels(const QVector<float
*/
QVector<float> QOpenGLShaderProgram::defaultInnerTessellationLevels() const
{
#ifndef QT_OPENGL_ES_2
QVector<float> tessLevels(2, 1.0f);
#if defined(QT_OPENGL_4)
Q_D(const QOpenGLShaderProgram);
if (d->tessellationFuncs)
d->tessellationFuncs->glGetFloatv(GL_PATCH_DEFAULT_INNER_LEVEL, tessLevels.data());
#endif
return tessLevels;
#else
return QVector<float>();
#endif
}
@ -3404,16 +3469,11 @@ QVector<float> QOpenGLShaderProgram::defaultInnerTessellationLevels() const
*/
bool QOpenGLShaderProgram::hasOpenGLShaderPrograms(QOpenGLContext *context)
{
#if !defined(QT_OPENGL_ES_2)
if (!context)
context = QOpenGLContext::currentContext();
if (!context)
return false;
return QOpenGLFunctions(context).hasOpenGLFeature(QOpenGLFunctions::Shaders);
#else
Q_UNUSED(context);
return true;
#endif
}
/*!
@ -3444,33 +3504,12 @@ bool QOpenGLShader::hasOpenGLShaders(ShaderType type, QOpenGLContext *context)
if ((type & ~(Geometry | Vertex | Fragment | TessellationControl | TessellationEvaluation | Compute)) || type == 0)
return false;
QSurfaceFormat format = context->format();
if (type == Geometry) {
#ifndef QT_OPENGL_ES_2
// Geometry shaders require OpenGL 3.2 or newer
QSurfaceFormat format = context->format();
return (!context->isOpenGLES())
&& (format.version() >= qMakePair<int, int>(3, 2));
#else
// No geometry shader support in OpenGL ES2
return false;
#endif
} else if (type == TessellationControl || type == TessellationEvaluation) {
#if !defined(QT_OPENGL_ES_2)
return (!context->isOpenGLES())
&& (format.version() >= qMakePair<int, int>(4, 0));
#else
// No tessellation shader support in OpenGL ES2
return false;
#endif
} else if (type == Compute) {
#if defined(QT_OPENGL_4_3)
return (format.version() >= qMakePair<int, int>(4, 3));
#else
// No compute shader support without OpenGL 4.3 or newer
return false;
#endif
}
if (type & QOpenGLShader::Geometry)
return supportsGeometry(context->format());
else if (type & (QOpenGLShader::TessellationControl | QOpenGLShader::TessellationEvaluation))
return supportsTessellation(context->format());
else if (type & QOpenGLShader::Compute)
return supportsCompute(context->format());
// Unconditional support of vertex and fragment shaders implicitly assumes
// a minimum OpenGL version of 2.0