summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qgl.cpp182
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qglbuffer.cpp60
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qglcolormap.cpp71
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qglfunctions.cpp86
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qglpixelbuffer.cpp69
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qglshaderprogram.cpp104
-rw-r--r--src/opengl/doc/snippets/code/src_opengl_qgraphicsshadereffect.cpp95
-rw-r--r--src/opengl/doc/src/qtopengl-examples.qdoc9
-rw-r--r--src/opengl/doc/src/qtopengl-module.qdoc13
-rw-r--r--src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp173
-rw-r--r--src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h167
-rw-r--r--src/opengl/gl2paintengineex/qglcustomshaderstage.cpp137
-rw-r--r--src/opengl/gl2paintengineex/qglcustomshaderstage_p.h86
-rw-r--r--src/opengl/gl2paintengineex/qglengineshadermanager.cpp875
-rw-r--r--src/opengl/gl2paintengineex/qglengineshadermanager_p.h508
-rw-r--r--src/opengl/gl2paintengineex/qglengineshadersource_p.h523
-rw-r--r--src/opengl/gl2paintengineex/qglgradientcache.cpp225
-rw-r--r--src/opengl/gl2paintengineex/qglgradientcache_p.h103
-rw-r--r--src/opengl/gl2paintengineex/qglshadercache_p.h86
-rw-r--r--src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp2515
-rw-r--r--src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h334
-rw-r--r--src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp414
-rw-r--r--src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h171
-rw-r--r--src/opengl/opengl.pro49
-rw-r--r--src/opengl/qgl.cpp5558
-rw-r--r--src/opengl/qgl.h524
-rw-r--r--src/opengl/qgl_p.h556
-rw-r--r--src/opengl/qglbuffer.cpp568
-rw-r--r--src/opengl/qglbuffer.h125
-rw-r--r--src/opengl/qglcolormap.cpp296
-rw-r--r--src/opengl/qglcolormap.h99
-rw-r--r--src/opengl/qglframebufferobject.cpp1466
-rw-r--r--src/opengl/qglframebufferobject.h149
-rw-r--r--src/opengl/qglframebufferobject_p.h157
-rw-r--r--src/opengl/qglfunctions.cpp1330
-rw-r--r--src/opengl/qglfunctions.h1688
-rw-r--r--src/opengl/qglpaintdevice.cpp239
-rw-r--r--src/opengl/qglpaintdevice_p.h113
-rw-r--r--src/opengl/qglpixelbuffer.cpp654
-rw-r--r--src/opengl/qglpixelbuffer.h104
-rw-r--r--src/opengl/qglpixelbuffer_p.h107
-rw-r--r--src/opengl/qglshaderprogram.cpp3237
-rw-r--r--src/opengl/qglshaderprogram.h303
-rw-r--r--src/opengl/qgraphicsshadereffect.cpp272
-rw-r--r--src/opengl/qgraphicsshadereffect_p.h90
45 files changed, 8 insertions, 24682 deletions
diff --git a/src/opengl/doc/snippets/code/src_opengl_qgl.cpp b/src/opengl/doc/snippets/code/src_opengl_qgl.cpp
deleted file mode 100644
index a73ee2cdc5..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qgl.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
-QGLFormat fmt;
-fmt.setAlpha(true);
-fmt.setStereo(true);
-QGLFormat::setDefaultFormat(fmt);
-//! [0]
-
-
-//! [1]
-QGLFormat fmt;
-fmt.setDoubleBuffer(false); // single buffer
-fmt.setDirectRendering(false); // software rendering
-MyGLWidget* myWidget = new MyGLWidget(fmt, ...);
-//! [1]
-
-
-//! [2]
-QGLFormat fmt;
-fmt.setOverlay(true);
-fmt.setStereo(true);
-MyGLWidget* myWidget = new MyGLWidget(fmt, ...);
-if (!myWidget->format().stereo()) {
- // ok, goggles off
- if (!myWidget->format().hasOverlay()) {
- qFatal("Cool hardware required");
- }
-}
-//! [2]
-
-
-//! [3]
-// The rendering in MyGLWidget depends on using
-// stencil buffer and alpha channel
-MyGLWidget::MyGLWidget(QWidget* parent)
- : QGLWidget(QGLFormat(QGL::StencilBuffer | QGL::AlphaChannel), parent)
-{
- if (!format().stencil())
- qWarning("Could not get stencil buffer; results will be suboptimal");
- if (!format().alpha())
- qWarning("Could not get alpha channel; results will be suboptimal");
- ...
-}
-//! [3]
-
-
-//! [4]
-QApplication a(argc, argv);
-QGLFormat f;
-f.setDoubleBuffer(false);
-QGLFormat::setDefaultFormat(f);
-//! [4]
-
-
-//! [5]
-QGLFormat f = QGLFormat::defaultOverlayFormat();
-f.setDoubleBuffer(true);
-QGLFormat::setDefaultOverlayFormat(f);
-//! [5]
-
-
-//! [6]
-// ...continued from above
-MyGLWidget* myWidget = new MyGLWidget(QGLFormat(QGL::HasOverlay), ...);
-if (myWidget->format().hasOverlay()) {
- // Yes, we got an overlay, let's check _its_ format:
- QGLContext* olContext = myWidget->overlayContext();
- if (olContext->format().doubleBuffer())
- ; // yes, we got a double buffered overlay
- else
- ; // no, only single buffered overlays are available
-}
-//! [6]
-
-
-//! [7]
-QGLContext *cx;
-// ...
-QGLFormat f;
-f.setStereo(true);
-cx->setFormat(f);
-if (!cx->create())
- exit(); // no OpenGL support, or cannot render on the specified paintdevice
-if (!cx->format().stereo())
- exit(); // could not create stereo context
-//! [7]
-
-
-//! [8]
-class MyGLDrawer : public QGLWidget
-{
- Q_OBJECT // must include this if you use Qt signals/slots
-
-public:
- MyGLDrawer(QWidget *parent)
- : QGLWidget(parent) {}
-
-protected:
-
- void initializeGL() override
- {
- // Set up the rendering context, define display lists etc.:
- ...
- glClearColor(0.0, 0.0, 0.0, 0.0);
- glEnable(GL_DEPTH_TEST);
- ...
- }
-
- void resizeGL(int w, int h) override
- {
- // setup viewport, projection etc.:
- glViewport(0, 0, (GLint)w, (GLint)h);
- ...
- glFrustum(...);
- ...
- }
-
- void paintGL() override
- {
- // draw the scene:
- ...
- glRotatef(...);
- glMaterialfv(...);
- glBegin(GL_QUADS);
- glVertex3f(...);
- glVertex3f(...);
- ...
- glEnd();
- ...
- }
-
-};
-//! [8]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qglbuffer.cpp b/src/opengl/doc/snippets/code/src_opengl_qglbuffer.cpp
deleted file mode 100644
index 11ef88ab37..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qglbuffer.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2018 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
- QGLBuffer buffer1(QGLBuffer::IndexBuffer);
- buffer1.create();
-
- QGLBuffer buffer2 = buffer1;
-//! [0]
-
-//! [1]
- QGLBuffer::release(QGLBuffer::VertexBuffer);
-//! [1]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qglcolormap.cpp b/src/opengl/doc/snippets/code/src_opengl_qglcolormap.cpp
deleted file mode 100644
index 12a089944f..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qglcolormap.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
-#include <QApplication>
-#include <QGLColormap>
-
-int main()
-{
- QApplication app(argc, argv);
-
- MySuperGLWidget widget; // a QGLWidget in color-index mode
- QGLColormap colormap;
-
- // This will fill the colormap with colors ranging from
- // black to white.
- for (int i = 0; i < colormap.size(); i++)
- colormap.setEntry(i, qRgb(i, i, i));
-
- widget.setColormap(colormap);
- widget.show();
- return app.exec();
-}
-//! [0]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qglfunctions.cpp b/src/opengl/doc/snippets/code/src_opengl_qglfunctions.cpp
deleted file mode 100644
index c848ae7ede..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qglfunctions.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2018 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
- class MyGLWidget : public QGLWidget, protected QGLFunctions
- {
- Q_OBJECT
- public:
- MyGLWidget(QWidget *parent = 0) : QGLWidget(parent) {}
-
- protected:
- void initializeGL();
- void paintGL();
- };
-
- void MyGLWidget::initializeGL()
- {
- initializeGLFunctions();
- }
-//! [0]
-
-//! [1]
- void MyGLWidget::paintGL()
- {
- glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D, textureId);
- ...
- }
-//! [1]
-
-//! [2]
- QGLFunctions glFuncs(QGLContext::currentContext());
- glFuncs.glActiveTexture(GL_TEXTURE1);
-//! [2]
-
-//! [3]
- QGLFunctions funcs(QGLContext::currentContext());
- bool npot = funcs.hasOpenGLFeature(QGLFunctions::NPOTTextures);
-//! [3]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qglpixelbuffer.cpp b/src/opengl/doc/snippets/code/src_opengl_qglpixelbuffer.cpp
deleted file mode 100644
index f6fbe6ddb4..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qglpixelbuffer.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
-QGLPixelBuffer pbuffer(...);
-...
-pbuffer.makeCurrent();
-GLuint dynamicTexture = pbuffer.generateDynamicTexture();
-pbuffer.bindToDynamicTexture(dynamicTexture);
-...
-pbuffer.releaseFromDynamicTexture();
-//! [0]
-
-
-//! [1]
-QGLPixelBuffer pbuffer(...);
-...
-pbuffer.makeCurrent();
-GLuint dynamicTexture = pbuffer.generateDynamicTexture();
-...
-pbuffer.updateDynamicTexture(dynamicTexture);
-//! [1]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qglshaderprogram.cpp b/src/opengl/doc/snippets/code/src_opengl_qglshaderprogram.cpp
deleted file mode 100644
index 04492499e8..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qglshaderprogram.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
-QGLShader shader(QGLShader::Vertex);
-shader.compileSourceCode(code);
-
-QGLShaderProgram program(context);
-program.addShader(shader);
-program.link();
-
-program.bind();
-//! [0]
-
-//! [1]
-program.addShaderFromSourceCode(QGLShader::Vertex,
- "attribute highp vec4 vertex;\n"
- "uniform highp mat4 matrix;\n"
- "void main(void)\n"
- "{\n"
- " gl_Position = matrix * vertex;\n"
- "}");
-program.addShaderFromSourceCode(QGLShader::Fragment,
- "uniform mediump vec4 color;\n"
- "void main(void)\n"
- "{\n"
- " gl_FragColor = color;\n"
- "}");
-program.link();
-program.bind();
-
-int vertexLocation = program.attributeLocation("vertex");
-int matrixLocation = program.uniformLocation("matrix");
-int colorLocation = program.uniformLocation("color");
-//! [1]
-
-//! [2]
-static GLfloat const triangleVertices[] = {
- 60.0f, 10.0f, 0.0f,
- 110.0f, 110.0f, 0.0f,
- 10.0f, 110.0f, 0.0f
-};
-
-QColor color(0, 255, 0, 255);
-
-QMatrix4x4 pmvMatrix;
-pmvMatrix.ortho(rect());
-
-program.enableAttributeArray(vertexLocation);
-program.setAttributeArray(vertexLocation, triangleVertices, 3);
-program.setUniformValue(matrixLocation, pmvMatrix);
-program.setUniformValue(colorLocation, color);
-
-glDrawArrays(GL_TRIANGLES, 0, 3);
-
-program.disableAttributeArray(vertexLocation);
-//! [2]
diff --git a/src/opengl/doc/snippets/code/src_opengl_qgraphicsshadereffect.cpp b/src/opengl/doc/snippets/code/src_opengl_qgraphicsshadereffect.cpp
deleted file mode 100644
index 461e96e094..0000000000
--- a/src/opengl/doc/snippets/code/src_opengl_qgraphicsshadereffect.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2018 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the documentation of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** BSD License Usage
-** Alternatively, 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$
-**
-****************************************************************************/
-
-//! [0]
- static char const colorizeShaderCode[] =
- "uniform lowp vec4 effectColor;\n"
- "lowp vec4 customShader(lowp sampler2D imageTexture, highp vec2 textureCoords) {\n"
- " vec4 src = texture2D(imageTexture, textureCoords);\n"
- " float gray = dot(src.rgb, vec3(0.212671, 0.715160, 0.072169));\n"
- " vec4 colorize = 1.0-((1.0-gray)*(1.0-effectColor));\n"
- " return vec4(colorize.rgb, src.a);\n"
- "}";
-//! [0]
-
-//! [1]
- class ColorizeEffect : public QGraphicsShaderEffect
- {
- Q_OBJECT
- public:
- ColorizeEffect(QObject *parent = 0)
- : QGraphicsShaderEffect(parent), color(Qt::black)
- {
- setPixelShaderFragment(colorizeShaderCode);
- }
-
- QColor effectColor() const { return color; }
- void setEffectColor(const QColor& c)
- {
- color = c;
- setUniformsDirty();
- }
-
- protected:
- void setUniforms(QGLShaderProgram *program)
- {
- program->setUniformValue("effectColor", color);
- }
-
- private:
- QColor color;
- };
-//! [1]
-
-//! [2]
- lowp vec4 customShader(lowp sampler2D imageTexture, highp vec2 textureCoords) {
- return texture2D(imageTexture, textureCoords);
- }
-//! [2]
diff --git a/src/opengl/doc/src/qtopengl-examples.qdoc b/src/opengl/doc/src/qtopengl-examples.qdoc
index de80c92883..8770d6247e 100644
--- a/src/opengl/doc/src/qtopengl-examples.qdoc
+++ b/src/opengl/doc/src/qtopengl-examples.qdoc
@@ -33,12 +33,11 @@
\image opengl-examples.png
- These examples describe how to use the \l {Qt OpenGL} module. For new code,
- please use the OpenGL classes in the \l {Qt GUI} module.
+ These examples describe how to use the \l {Qt OpenGL} module.
- Qt provides support for integration with OpenGL implementations on all
- platforms, giving developers the opportunity to display hardware accelerated
- 3D graphics alongside a more conventional user interface.
+ Qt provides support for integration with OpenGL implementations, giving
+ developers the opportunity to display hardware accelerated 3D graphics
+ alongside a more conventional user interface.
These examples demonstrate the basic techniques used to take advantage of
OpenGL in Qt applications.
diff --git a/src/opengl/doc/src/qtopengl-module.qdoc b/src/opengl/doc/src/qtopengl-module.qdoc
index 336d37c73f..24df4aec76 100644
--- a/src/opengl/doc/src/qtopengl-module.qdoc
+++ b/src/opengl/doc/src/qtopengl-module.qdoc
@@ -34,8 +34,7 @@
\brief The Qt OpenGL module offers classes that make it easy to
use OpenGL in Qt applications.
- \warning This module should not be used anymore for new code. Please
- use the corresponding OpenGL classes in \l{Qt GUI}.
+ \warning This module should not be used anymore for new code.
OpenGL is a standard API for rendering 3D graphics. OpenGL only
deals with 3D rendering and provides little or no support for GUI
@@ -48,9 +47,6 @@
the United States and other countries.
The Qt OpenGL module makes it easy to use OpenGL in Qt applications.
- It provides an OpenGL widget class that can be used just like any
- other Qt widget, except that it opens an OpenGL display buffer where
- you can use the OpenGL API to render the contents.
To include the definitions of the module's classes, use the
following directive:
@@ -63,11 +59,4 @@
\snippet code/doc_src_qtopengl.pro 1
\endif
-
- The Qt OpenGL module is implemented as a platform-independent Qt/C++
- wrapper around the platform-dependent GLX (version 1.3 or later),
- WGL, or AGL C APIs. Although the basic functionality provided is very
- similar to Mark Kilgard's GLUT library, applications using the Qt
- OpenGL module can take advantage of the whole Qt API for
- non-OpenGL-specific GUI functionality.
*/
diff --git a/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp b/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp
deleted file mode 100644
index 979ea19fee..0000000000
--- a/src/opengl/gl2paintengineex/qgl2pexvertexarray.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qgl2pexvertexarray_p.h"
-
-#include <private/qbezier_p.h>
-
-QT_BEGIN_NAMESPACE
-
-void QGL2PEXVertexArray::clear()
-{
- vertexArray.reset();
- vertexArrayStops.reset();
- boundingRectDirty = true;
-}
-
-
-QGLRect QGL2PEXVertexArray::boundingRect() const
-{
- if (boundingRectDirty)
- return QGLRect(0.0, 0.0, 0.0, 0.0);
- else
- return QGLRect(minX, minY, maxX, maxY);
-}
-
-void QGL2PEXVertexArray::addClosingLine(int index)
-{
- QPointF point(vertexArray.at(index));
- if (point != QPointF(vertexArray.last()))
- vertexArray.add(point);
-}
-
-void QGL2PEXVertexArray::addCentroid(const QVectorPath &path, int subPathIndex)
-{
- const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());
- const QPainterPath::ElementType *const elements = path.elements();
-
- QPointF sum = points[subPathIndex];
- int count = 1;
-
- for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {
- sum += points[i];
- ++count;
- }
-
- const QPointF centroid = sum / qreal(count);
- vertexArray.add(centroid);
-}
-
-void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline)
-{
- const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
- const QPainterPath::ElementType* const elements = path.elements();
-
- if (boundingRectDirty) {
- minX = maxX = points[0].x();
- minY = maxY = points[0].y();
- boundingRectDirty = false;
- }
-
- if (!outline && !path.isConvex())
- addCentroid(path, 0);
-
- int lastMoveTo = vertexArray.size();
- vertexArray.add(points[0]); // The first element is always a moveTo
-
- do {
- if (!elements) {
-// qDebug("QVectorPath has no elements");
- // If the path has a null elements pointer, the elements implicitly
- // start with a moveTo (already added) and continue with lineTos:
- for (int i=1; i<path.elementCount(); ++i)
- lineToArray(points[i].x(), points[i].y());
-
- break;
- }
-// qDebug("QVectorPath has element types");
-
- for (int i=1; i<path.elementCount(); ++i) {
- switch (elements[i]) {
- case QPainterPath::MoveToElement:
- if (!outline)
- addClosingLine(lastMoveTo);
-// qDebug("element[%d] is a MoveToElement", i);
- vertexArrayStops.add(vertexArray.size());
- if (!outline) {
- if (!path.isConvex()) addCentroid(path, i);
- lastMoveTo = vertexArray.size();
- }
- lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex
- break;
- case QPainterPath::LineToElement:
-// qDebug("element[%d] is a LineToElement", i);
- lineToArray(points[i].x(), points[i].y());
- break;
- case QPainterPath::CurveToElement: {
- QBezier b = QBezier::fromPoints(*(((const QPointF *) points) + i - 1),
- points[i],
- points[i+1],
- points[i+2]);
- QRectF bounds = b.bounds();
- // threshold based on same algorithm as in qtriangulatingstroker.cpp
- int threshold = qMin<float>(64, qMax(bounds.width(), bounds.height()) * 3.14f / (curveInverseScale * 6));
- if (threshold < 3) threshold = 3;
- qreal one_over_threshold_minus_1 = qreal(1) / (threshold - 1);
- for (int t=0; t<threshold; ++t) {
- QPointF pt = b.pointAt(t * one_over_threshold_minus_1);
- lineToArray(pt.x(), pt.y());
- }
- i += 2;
- break; }
- default:
- break;
- }
- }
- } while (0);
-
- if (!outline)
- addClosingLine(lastMoveTo);
- vertexArrayStops.add(vertexArray.size());
-}
-
-void QGL2PEXVertexArray::lineToArray(const GLfloat x, const GLfloat y)
-{
- vertexArray.add(QGLPoint(x, y));
-
- if (x > maxX)
- maxX = x;
- else if (x < minX)
- minX = x;
- if (y > maxY)
- maxY = y;
- else if (y < minY)
- minY = y;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h b/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h
deleted file mode 100644
index 5c95268790..0000000000
--- a/src/opengl/gl2paintengineex/qgl2pexvertexarray_p.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#ifndef QGL2PEXVERTEXARRAY_P_H
-#define QGL2PEXVERTEXARRAY_P_H
-
-#include <QRectF>
-
-#include <private/qdatabuffer_p.h>
-#include <private/qvectorpath_p.h>
-#include <private/qgl_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QGLPoint
-{
-public:
- QGLPoint(GLfloat new_x, GLfloat new_y) :
- x(new_x), y(new_y) {};
-
- QGLPoint(const QPointF &p) :
- x(p.x()), y(p.y()) {};
-
- QGLPoint(const QPointF* p) :
- x(p->x()), y(p->y()) {};
-
- GLfloat x;
- GLfloat y;
-
- operator QPointF() {return QPointF(x,y);}
- operator QPointF() const {return QPointF(x,y);}
-};
-
-struct QGLRect
-{
- QGLRect(const QRectF &r)
- : left(r.left()), top(r.top()), right(r.right()), bottom(r.bottom()) {}
-
- QGLRect(GLfloat l, GLfloat t, GLfloat r, GLfloat b)
- : left(l), top(t), right(r), bottom(b) {}
-
- GLfloat left;
- GLfloat top;
- GLfloat right;
- GLfloat bottom;
-
- operator QRectF() const {return QRectF(left, top, right-left, bottom-top);}
-};
-
-class QGL2PEXVertexArray
-{
-public:
- QGL2PEXVertexArray() :
- vertexArray(0), vertexArrayStops(0),
- maxX(-2e10), maxY(-2e10), minX(2e10), minY(2e10),
- boundingRectDirty(true)
- { }
-
- inline void addRect(const QRectF &rect)
- {
- qreal top = rect.top();
- qreal left = rect.left();
- qreal bottom = rect.bottom();
- qreal right = rect.right();
-
- vertexArray << QGLPoint(left, top)
- << QGLPoint(right, top)
- << QGLPoint(right, bottom)
- << QGLPoint(right, bottom)
- << QGLPoint(left, bottom)
- << QGLPoint(left, top);
- }
-
- inline void addQuad(const QRectF &rect)
- {
- qreal top = rect.top();
- qreal left = rect.left();
- qreal bottom = rect.bottom();
- qreal right = rect.right();
-
- vertexArray << QGLPoint(left, top)
- << QGLPoint(right, top)
- << QGLPoint(left, bottom)
- << QGLPoint(right, bottom);
-
- }
-
- inline void addVertex(const GLfloat x, const GLfloat y)
- {
- vertexArray.add(QGLPoint(x, y));
- }
-
- void addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline = true);
- void clear();
-
- QGLPoint* data() {return vertexArray.data();}
- int *stops() const { return vertexArrayStops.data(); }
- int stopCount() const { return vertexArrayStops.size(); }
- QGLRect boundingRect() const;
-
- int vertexCount() const { return vertexArray.size(); }
-
- void lineToArray(const GLfloat x, const GLfloat y);
-
-private:
- QDataBuffer<QGLPoint> vertexArray;
- QDataBuffer<int> vertexArrayStops;
-
- GLfloat maxX;
- GLfloat maxY;
- GLfloat minX;
- GLfloat minY;
- bool boundingRectDirty;
- void addClosingLine(int index);
- void addCentroid(const QVectorPath &path, int subPathIndex);
-};
-
-QT_END_NAMESPACE
-
-#endif
diff --git a/src/opengl/gl2paintengineex/qglcustomshaderstage.cpp b/src/opengl/gl2paintengineex/qglcustomshaderstage.cpp
deleted file mode 100644
index 7d6d4595ba..0000000000
--- a/src/opengl/gl2paintengineex/qglcustomshaderstage.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qglcustomshaderstage_p.h"
-#include "qglengineshadermanager_p.h"
-#include "qpaintengineex_opengl2_p.h"
-#include <private/qpainter_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QGLCustomShaderStagePrivate
-{
-public:
- QGLCustomShaderStagePrivate() :
- m_manager(0) {}
-
- QPointer<QGLEngineShaderManager> m_manager;
- QByteArray m_source;
-};
-
-
-
-
-QGLCustomShaderStage::QGLCustomShaderStage()
- : d_ptr(new QGLCustomShaderStagePrivate)
-{
-}
-
-QGLCustomShaderStage::~QGLCustomShaderStage()
-{
- Q_D(QGLCustomShaderStage);
- if (d->m_manager) {
- d->m_manager->removeCustomStage();
- d->m_manager->sharedShaders->cleanupCustomStage(this);
- }
- delete d_ptr;
-}
-
-void QGLCustomShaderStage::setUniformsDirty()
-{
- Q_D(QGLCustomShaderStage);
- if (d->m_manager)
- d->m_manager->setDirty(); // ### Probably a bit overkill!
-}
-
-bool QGLCustomShaderStage::setOnPainter(QPainter* p)
-{
- Q_D(QGLCustomShaderStage);
- if (p->paintEngine()->type() != QPaintEngine::OpenGL2) {
- qWarning("QGLCustomShaderStage::setOnPainter() - paint engine not OpenGL2");
- return false;
- }
- if (d->m_manager)
- qWarning("Custom shader is already set on a painter");
-
- QGL2PaintEngineEx *engine = static_cast<QGL2PaintEngineEx*>(p->paintEngine());
- d->m_manager = QGL2PaintEngineExPrivate::shaderManagerForEngine(engine);
- Q_ASSERT(d->m_manager);
-
- d->m_manager->setCustomStage(this);
- return true;
-}
-
-void QGLCustomShaderStage::removeFromPainter(QPainter* p)
-{
- Q_D(QGLCustomShaderStage);
- if (p->paintEngine()->type() != QPaintEngine::OpenGL2)
- return;
-
- QGL2PaintEngineEx *engine = static_cast<QGL2PaintEngineEx*>(p->paintEngine());
- d->m_manager = QGL2PaintEngineExPrivate::shaderManagerForEngine(engine);
- Q_ASSERT(d->m_manager);
-
- // Just set the stage to null, don't call removeCustomStage().
- // This should leave the program in a compiled/linked state
- // if the next custom shader stage is this one again.
- d->m_manager->setCustomStage(0);
- d->m_manager = 0;
-}
-
-QByteArray QGLCustomShaderStage::source() const
-{
- Q_D(const QGLCustomShaderStage);
- return d->m_source;
-}
-
-// Called by the shader manager if another custom shader is attached or
-// the manager is deleted
-void QGLCustomShaderStage::setInactive()
-{
- Q_D(QGLCustomShaderStage);
- d->m_manager = 0;
-}
-
-void QGLCustomShaderStage::setSource(const QByteArray& s)
-{
- Q_D(QGLCustomShaderStage);
- d->m_source = s;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qglcustomshaderstage_p.h b/src/opengl/gl2paintengineex/qglcustomshaderstage_p.h
deleted file mode 100644
index 77421ebdd3..0000000000
--- a/src/opengl/gl2paintengineex/qglcustomshaderstage_p.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGL_CUSTOM_SHADER_STAGE_H
-#define QGL_CUSTOM_SHADER_STAGE_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QGLShaderProgram>
-
-QT_BEGIN_NAMESPACE
-
-
-class QGLCustomShaderStagePrivate;
-class Q_OPENGL_EXPORT QGLCustomShaderStage
-{
- Q_DECLARE_PRIVATE(QGLCustomShaderStage)
-public:
- QGLCustomShaderStage();
- virtual ~QGLCustomShaderStage();
- virtual void setUniforms(QGLShaderProgram*) {}
-
- void setUniformsDirty();
-
- bool setOnPainter(QPainter*);
- void removeFromPainter(QPainter*);
- QByteArray source() const;
-
- void setInactive();
-protected:
- void setSource(const QByteArray&);
-
-private:
- QGLCustomShaderStagePrivate* d_ptr;
-};
-
-
-QT_END_NAMESPACE
-
-
-#endif
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp b/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
deleted file mode 100644
index 47e8531959..0000000000
--- a/src/opengl/gl2paintengineex/qglengineshadermanager.cpp
+++ /dev/null
@@ -1,875 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qglengineshadermanager_p.h"
-#include "qglengineshadersource_p.h"
-#include "qpaintengineex_opengl2_p.h"
-#include "qglshadercache_p.h"
-
-#include <QtGui/private/qopenglcontext_p.h>
-
-#if defined(QT_DEBUG)
-#include <QMetaEnum>
-#endif
-
-#include <algorithm>
-
-// #define QT_GL_SHARED_SHADER_DEBUG
-
-QT_BEGIN_NAMESPACE
-
-class QGLEngineSharedShadersResource : public QOpenGLSharedResource
-{
-public:
- QGLEngineSharedShadersResource(QOpenGLContext *ctx)
- : QOpenGLSharedResource(ctx->shareGroup())
- , m_shaders(new QGLEngineSharedShaders(QGLContext::fromOpenGLContext(ctx)))
- {
- }
-
- ~QGLEngineSharedShadersResource()
- {
- delete m_shaders;
- }
-
- void invalidateResource() override
- {
- delete m_shaders;
- m_shaders = 0;
- }
-
- void freeResource(QOpenGLContext *) override
- {
- }
-
- QGLEngineSharedShaders *shaders() const { return m_shaders; }
-
-private:
- QGLEngineSharedShaders *m_shaders;
-};
-
-class QGLShaderStorage
-{
-public:
- QGLEngineSharedShaders *shadersForThread(const QGLContext *context) {
- QOpenGLMultiGroupSharedResource *&shaders = m_storage.localData();
- if (!shaders)
- shaders = new QOpenGLMultiGroupSharedResource;
- QGLEngineSharedShadersResource *resource =
- shaders->value<QGLEngineSharedShadersResource>(context->contextHandle());
- return resource ? resource->shaders() : 0;
- }
-
-private:
- QThreadStorage<QOpenGLMultiGroupSharedResource *> m_storage;
-};
-
-Q_GLOBAL_STATIC(QGLShaderStorage, qt_shader_storage);
-
-QGLEngineSharedShaders *QGLEngineSharedShaders::shadersForContext(const QGLContext *context)
-{
- return qt_shader_storage()->shadersForThread(context);
-}
-
-const char* QGLEngineSharedShaders::qShaderSnippets[] = {
- 0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0
-};
-
-QGLEngineSharedShaders::QGLEngineSharedShaders(const QGLContext* context)
- : blitShaderProg(0)
- , simpleShaderProg(0)
-{
-
-/*
- Rather than having the shader source array statically initialised, it is initialised
- here instead. This is to allow new shader names to be inserted or existing names moved
- around without having to change the order of the glsl strings. It is hoped this will
- make future hard-to-find runtime bugs more obvious and generally give more solid code.
-*/
- static bool snippetsPopulated = false;
- if (!snippetsPopulated) {
-
- const char** code = qShaderSnippets; // shortcut
-
- code[MainVertexShader] = qglslMainVertexShader;
- code[MainWithTexCoordsVertexShader] = qglslMainWithTexCoordsVertexShader;
- code[MainWithTexCoordsAndOpacityVertexShader] = qglslMainWithTexCoordsAndOpacityVertexShader;
-
- code[UntransformedPositionVertexShader] = qglslUntransformedPositionVertexShader;
- code[PositionOnlyVertexShader] = qglslPositionOnlyVertexShader;
- code[ComplexGeometryPositionOnlyVertexShader] = qglslComplexGeometryPositionOnlyVertexShader;
- code[PositionWithPatternBrushVertexShader] = qglslPositionWithPatternBrushVertexShader;
- code[PositionWithLinearGradientBrushVertexShader] = qglslPositionWithLinearGradientBrushVertexShader;
- code[PositionWithConicalGradientBrushVertexShader] = qglslPositionWithConicalGradientBrushVertexShader;
- code[PositionWithRadialGradientBrushVertexShader] = qglslPositionWithRadialGradientBrushVertexShader;
- code[PositionWithTextureBrushVertexShader] = qglslPositionWithTextureBrushVertexShader;
- code[AffinePositionWithPatternBrushVertexShader] = qglslAffinePositionWithPatternBrushVertexShader;
- code[AffinePositionWithLinearGradientBrushVertexShader] = qglslAffinePositionWithLinearGradientBrushVertexShader;
- code[AffinePositionWithConicalGradientBrushVertexShader] = qglslAffinePositionWithConicalGradientBrushVertexShader;
- code[AffinePositionWithRadialGradientBrushVertexShader] = qglslAffinePositionWithRadialGradientBrushVertexShader;
- code[AffinePositionWithTextureBrushVertexShader] = qglslAffinePositionWithTextureBrushVertexShader;
-
- code[MainFragmentShader_CMO] = qglslMainFragmentShader_CMO;
- code[MainFragmentShader_CM] = qglslMainFragmentShader_CM;
- code[MainFragmentShader_MO] = qglslMainFragmentShader_MO;
- code[MainFragmentShader_M] = qglslMainFragmentShader_M;
- code[MainFragmentShader_CO] = qglslMainFragmentShader_CO;
- code[MainFragmentShader_C] = qglslMainFragmentShader_C;
- code[MainFragmentShader_O] = qglslMainFragmentShader_O;
- code[MainFragmentShader] = qglslMainFragmentShader;
- code[MainFragmentShader_ImageArrays] = qglslMainFragmentShader_ImageArrays;
-
- code[ImageSrcFragmentShader] = qglslImageSrcFragmentShader;
- code[ImageSrcWithPatternFragmentShader] = qglslImageSrcWithPatternFragmentShader;
- code[NonPremultipliedImageSrcFragmentShader] = qglslNonPremultipliedImageSrcFragmentShader;
- code[CustomImageSrcFragmentShader] = qglslCustomSrcFragmentShader; // Calls "customShader", which must be appended
- code[SolidBrushSrcFragmentShader] = qglslSolidBrushSrcFragmentShader;
- if (!context->contextHandle()->isOpenGLES())
- code[TextureBrushSrcFragmentShader] = qglslTextureBrushSrcFragmentShader_desktop;
- else
- code[TextureBrushSrcFragmentShader] = qglslTextureBrushSrcFragmentShader_ES;
- code[TextureBrushSrcWithPatternFragmentShader] = qglslTextureBrushSrcWithPatternFragmentShader;
- code[PatternBrushSrcFragmentShader] = qglslPatternBrushSrcFragmentShader;
- code[LinearGradientBrushSrcFragmentShader] = qglslLinearGradientBrushSrcFragmentShader;
- code[RadialGradientBrushSrcFragmentShader] = qglslRadialGradientBrushSrcFragmentShader;
- code[ConicalGradientBrushSrcFragmentShader] = qglslConicalGradientBrushSrcFragmentShader;
- code[ShockingPinkSrcFragmentShader] = qglslShockingPinkSrcFragmentShader;
-
- code[NoMaskFragmentShader] = "";
- code[MaskFragmentShader] = qglslMaskFragmentShader;
- code[RgbMaskFragmentShaderPass1] = qglslRgbMaskFragmentShaderPass1;
- code[RgbMaskFragmentShaderPass2] = qglslRgbMaskFragmentShaderPass2;
- code[RgbMaskWithGammaFragmentShader] = ""; //###
-
- code[NoCompositionModeFragmentShader] = "";
- code[MultiplyCompositionModeFragmentShader] = ""; //###
- code[ScreenCompositionModeFragmentShader] = ""; //###
- code[OverlayCompositionModeFragmentShader] = ""; //###
- code[DarkenCompositionModeFragmentShader] = ""; //###
- code[LightenCompositionModeFragmentShader] = ""; //###
- code[ColorDodgeCompositionModeFragmentShader] = ""; //###
- code[ColorBurnCompositionModeFragmentShader] = ""; //###
- code[HardLightCompositionModeFragmentShader] = ""; //###
- code[SoftLightCompositionModeFragmentShader] = ""; //###
- code[DifferenceCompositionModeFragmentShader] = ""; //###
- code[ExclusionCompositionModeFragmentShader] = ""; //###
-
-#if defined(QT_DEBUG)
- // Check that all the elements have been filled:
- for (int i = 0; i < TotalSnippetCount; ++i) {
- if (Q_UNLIKELY(!qShaderSnippets[i])) {
- qFatal("Shader snippet for %s (#%d) is missing!",
- snippetNameStr(SnippetName(i)).constData(), i);
- }
- }
-#endif
- snippetsPopulated = true;
- }
-
- QGLShader* fragShader;
- QGLShader* vertexShader;
- QByteArray vertexSource;
- QByteArray fragSource;
-
- // Compile up the simple shader:
- vertexSource.append(qShaderSnippets[MainVertexShader]);
- vertexSource.append(qShaderSnippets[PositionOnlyVertexShader]);
-
- fragSource.append(qShaderSnippets[MainFragmentShader]);
- fragSource.append(qShaderSnippets[ShockingPinkSrcFragmentShader]);
-
- simpleShaderProg = new QGLShaderProgram(context, 0);
-
- CachedShader simpleShaderCache(fragSource, vertexSource);
-
- bool inCache = simpleShaderCache.load(simpleShaderProg, context);
-
- if (!inCache) {
- vertexShader = new QGLShader(QGLShader::Vertex, context, 0);
- shaders.append(vertexShader);
- if (!vertexShader->compileSourceCode(vertexSource))
- qWarning("Vertex shader for simpleShaderProg (MainVertexShader & PositionOnlyVertexShader) failed to compile");
-
- fragShader = new QGLShader(QGLShader::Fragment, context, 0);
- shaders.append(fragShader);
- if (!fragShader->compileSourceCode(fragSource))
- qWarning("Fragment shader for simpleShaderProg (MainFragmentShader & ShockingPinkSrcFragmentShader) failed to compile");
-
- simpleShaderProg->addShader(vertexShader);
- simpleShaderProg->addShader(fragShader);
-
- simpleShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
- simpleShaderProg->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
- simpleShaderProg->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
- simpleShaderProg->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
- }
-
- simpleShaderProg->link();
-
- if (Q_UNLIKELY(!simpleShaderProg->isLinked())) {
- qCritical("Errors linking simple shader: %s", qPrintable(simpleShaderProg->log()));
- } else {
- if (!inCache)
- simpleShaderCache.store(simpleShaderProg, context);
- }
-
- // Compile the blit shader:
- vertexSource.clear();
- vertexSource.append(qShaderSnippets[MainWithTexCoordsVertexShader]);
- vertexSource.append(qShaderSnippets[UntransformedPositionVertexShader]);
-
- fragSource.clear();
- fragSource.append(qShaderSnippets[MainFragmentShader]);
- fragSource.append(qShaderSnippets[ImageSrcFragmentShader]);
-
- blitShaderProg = new QGLShaderProgram(context, 0);
-
- CachedShader blitShaderCache(fragSource, vertexSource);
-
- inCache = blitShaderCache.load(blitShaderProg, context);
-
- if (!inCache) {
- vertexShader = new QGLShader(QGLShader::Vertex, context, 0);
- shaders.append(vertexShader);
- if (!vertexShader->compileSourceCode(vertexSource))
- qWarning("Vertex shader for blitShaderProg (MainWithTexCoordsVertexShader & UntransformedPositionVertexShader) failed to compile");
-
- fragShader = new QGLShader(QGLShader::Fragment, context, 0);
- shaders.append(fragShader);
- if (!fragShader->compileSourceCode(fragSource))
- qWarning("Fragment shader for blitShaderProg (MainFragmentShader & ImageSrcFragmentShader) failed to compile");
-
- blitShaderProg->addShader(vertexShader);
- blitShaderProg->addShader(fragShader);
-
- blitShaderProg->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
- blitShaderProg->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
- }
-
- blitShaderProg->link();
- if (Q_UNLIKELY(!blitShaderProg->isLinked())) {
- qCritical("Errors linking blit shader: %s", qPrintable(blitShaderProg->log()));
- } else {
- if (!inCache)
- blitShaderCache.store(blitShaderProg, context);
- }
-
-#ifdef QT_GL_SHARED_SHADER_DEBUG
- qDebug(" -> QGLEngineSharedShaders() %p for thread %p.", this, QThread::currentThread());
-#endif
-}
-
-QGLEngineSharedShaders::~QGLEngineSharedShaders()
-{
-#ifdef QT_GL_SHARED_SHADER_DEBUG
- qDebug(" -> ~QGLEngineSharedShaders() %p for thread %p.", this, QThread::currentThread());
-#endif
- qDeleteAll(shaders);
- shaders.clear();
-
- qDeleteAll(cachedPrograms);
- cachedPrograms.clear();
-
- if (blitShaderProg) {
- delete blitShaderProg;
- blitShaderProg = 0;
- }
-
- if (simpleShaderProg) {
- delete simpleShaderProg;
- simpleShaderProg = 0;
- }
-}
-
-#if defined (QT_DEBUG)
-QByteArray QGLEngineSharedShaders::snippetNameStr(SnippetName name)
-{
- QMetaEnum m = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("SnippetName"));
- return QByteArray(m.valueToKey(name));
-}
-#endif
-
-// The address returned here will only be valid until next time this function is called.
-// The program is return bound.
-QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineShaderProg &prog)
-{
- for (int i = 0; i < cachedPrograms.size(); ++i) {
- QGLEngineShaderProg *cachedProg = cachedPrograms.at(i);
- if (*cachedProg == prog) {
- // Move the program to the top of the list as a poor-man's cache algo
- cachedPrograms.move(i, 0);
- cachedProg->program->bind();
- return cachedProg;
- }
- }
-
- QScopedPointer<QGLEngineShaderProg> newProg;
-
- do {
- QByteArray fragSource;
- // Insert the custom stage before the srcPixel shader to work around an ATI driver bug
- // where you cannot forward declare a function that takes a sampler as argument.
- if (prog.srcPixelFragShader == CustomImageSrcFragmentShader)
- fragSource.append(prog.customStageSource);
- fragSource.append(qShaderSnippets[prog.mainFragShader]);
- fragSource.append(qShaderSnippets[prog.srcPixelFragShader]);
- if (prog.compositionFragShader)
- fragSource.append(qShaderSnippets[prog.compositionFragShader]);
- if (prog.maskFragShader)
- fragSource.append(qShaderSnippets[prog.maskFragShader]);
-
- QByteArray vertexSource;
- vertexSource.append(qShaderSnippets[prog.mainVertexShader]);
- vertexSource.append(qShaderSnippets[prog.positionVertexShader]);
-
- QScopedPointer<QGLShaderProgram> shaderProgram(new QGLShaderProgram);
-
- CachedShader shaderCache(fragSource, vertexSource);
- bool inCache = shaderCache.load(shaderProgram.data(), QGLContext::currentContext());
-
- if (!inCache) {
-
- QScopedPointer<QGLShader> fragShader(new QGLShader(QGLShader::Fragment));
- QByteArray description;
-#if defined(QT_DEBUG)
- // Name the shader for easier debugging
- description.append("Fragment shader: main=");
- description.append(snippetNameStr(prog.mainFragShader));
- description.append(", srcPixel=");
- description.append(snippetNameStr(prog.srcPixelFragShader));
- if (prog.compositionFragShader) {
- description.append(", composition=");
- description.append(snippetNameStr(prog.compositionFragShader));
- }
- if (prog.maskFragShader) {
- description.append(", mask=");
- description.append(snippetNameStr(prog.maskFragShader));
- }
- fragShader->setObjectName(QString::fromLatin1(description));
-#endif
- if (!fragShader->compileSourceCode(fragSource)) {
- qWarning() << "Warning:" << description << "failed to compile!";
- break;
- }
-
- QScopedPointer<QGLShader> vertexShader(new QGLShader(QGLShader::Vertex));
-#if defined(QT_DEBUG)
- // Name the shader for easier debugging
- description.clear();
- description.append("Vertex shader: main=");
- description.append(snippetNameStr(prog.mainVertexShader));
- description.append(", position=");
- description.append(snippetNameStr(prog.positionVertexShader));
- vertexShader->setObjectName(QString::fromLatin1(description));
-#endif
- if (!vertexShader->compileSourceCode(vertexSource)) {
- qWarning() << "Warning:" << description << "failed to compile!";
- break;
- }
-
- shaders.append(vertexShader.data());
- shaders.append(fragShader.data());
- shaderProgram->addShader(vertexShader.take());
- shaderProgram->addShader(fragShader.take());
-
- // We have to bind the vertex attribute names before the program is linked:
- shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
- if (prog.useTextureCoords)
- shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
- if (prog.useOpacityAttribute)
- shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR);
- if (prog.usePmvMatrixAttribute) {
- shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR);
- shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR);
- shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR);
- }
- }
-
- newProg.reset(new QGLEngineShaderProg(prog));
- newProg->program = shaderProgram.take();
-
- newProg->program->link();
- if (newProg->program->isLinked()) {
- if (!inCache)
- shaderCache.store(newProg->program, QGLContext::currentContext());
- } else {
- QString error;
- error = QLatin1String("Shader program failed to link,");
-#if defined(QT_DEBUG)
- QLatin1String br("\n");
- error += QLatin1String("\n Shaders Used:\n");
- for (int i = 0; i < newProg->program->shaders().count(); ++i) {
- QGLShader *shader = newProg->program->shaders().at(i);
- error += QLatin1String(" ") + shader->objectName() + QLatin1String(": \n")
- + QLatin1String(shader->sourceCode()) + br;
- }
-#endif
- error += QLatin1String(" Error Log:\n")
- + QLatin1String(" ") + newProg->program->log();
- qWarning() << error;
- break;
- }
-
- newProg->program->bind();
-
- if (newProg->maskFragShader != QGLEngineSharedShaders::NoMaskFragmentShader) {
- GLuint location = newProg->program->uniformLocation("maskTexture");
- newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT);
- }
-
- if (cachedPrograms.count() > 30) {
- // The cache is full, so delete the last 5 programs in the list.
- // These programs will be least used, as a program us bumped to
- // the top of the list when it's used.
- for (int i = 0; i < 5; ++i) {
- delete cachedPrograms.last();
- cachedPrograms.removeLast();
- }
- }
-
- cachedPrograms.insert(0, newProg.data());
- } while (false);
-
- return newProg.take();
-}
-
-void QGLEngineSharedShaders::cleanupCustomStage(QGLCustomShaderStage* stage)
-{
- auto hasStageAsCustomShaderSouce = [stage](QGLEngineShaderProg *cachedProg) -> bool {
- if (cachedProg->customStageSource == stage->source()) {
- delete cachedProg;
- return true;
- }
- return false;
- };
- cachedPrograms.erase(std::remove_if(cachedPrograms.begin(), cachedPrograms.end(),
- hasStageAsCustomShaderSouce),
- cachedPrograms.end());
-}
-
-
-QGLEngineShaderManager::QGLEngineShaderManager(QGLContext* context)
- : ctx(context),
- shaderProgNeedsChanging(true),
- complexGeometry(false),
- srcPixelType(Qt::NoBrush),
- opacityMode(NoOpacity),
- maskType(NoMask),
- compositionMode(QPainter::CompositionMode_SourceOver),
- customSrcStage(0),
- currentShaderProg(0)
-{
- sharedShaders = QGLEngineSharedShaders::shadersForContext(context);
-}
-
-QGLEngineShaderManager::~QGLEngineShaderManager()
-{
- //###
- removeCustomStage();
-}
-
-GLuint QGLEngineShaderManager::getUniformLocation(Uniform id)
-{
- if (!currentShaderProg)
- return 0;
-
- QVector<uint> &uniformLocations = currentShaderProg->uniformLocations;
- if (uniformLocations.isEmpty())
- uniformLocations.fill(GLuint(-1), NumUniforms);
-
- static const char *const uniformNames[] = {
- "imageTexture",
- "patternColor",
- "globalOpacity",
- "depth",
- "maskTexture",
- "fragmentColor",
- "linearData",
- "angle",
- "halfViewportSize",
- "fmp",
- "fmp2_m_radius2",
- "inverse_2_fmp2_m_radius2",
- "sqrfr",
- "bradius",
- "invertedTextureSize",
- "brushTransform",
- "brushTexture",
- "matrix",
- "translateZ"
- };
-
- if (uniformLocations.at(id) == GLuint(-1))
- uniformLocations[id] = currentShaderProg->program->uniformLocation(uniformNames[id]);
-
- return uniformLocations.at(id);
-}
-
-
-void QGLEngineShaderManager::optimiseForBrushTransform(QTransform::TransformationType transformType)
-{
- Q_UNUSED(transformType); // Currently ignored
-}
-
-void QGLEngineShaderManager::setDirty()
-{
- shaderProgNeedsChanging = true;
-}
-
-void QGLEngineShaderManager::setSrcPixelType(Qt::BrushStyle style)
-{
- Q_ASSERT(style != Qt::NoBrush);
- if (srcPixelType == PixelSrcType(style))
- return;
-
- srcPixelType = style;
- shaderProgNeedsChanging = true; //###
-}
-
-void QGLEngineShaderManager::setSrcPixelType(PixelSrcType type)
-{
- if (srcPixelType == type)
- return;
-
- srcPixelType = type;
- shaderProgNeedsChanging = true; //###
-}
-
-void QGLEngineShaderManager::setOpacityMode(OpacityMode mode)
-{
- if (opacityMode == mode)
- return;
-
- opacityMode = mode;
- shaderProgNeedsChanging = true; //###
-}
-
-void QGLEngineShaderManager::setMaskType(MaskType type)
-{
- if (maskType == type)
- return;
-
- maskType = type;
- shaderProgNeedsChanging = true; //###
-}
-
-void QGLEngineShaderManager::setCompositionMode(QPainter::CompositionMode mode)
-{
- if (compositionMode == mode)
- return;
-
- compositionMode = mode;
- shaderProgNeedsChanging = true; //###
-}
-
-void QGLEngineShaderManager::setCustomStage(QGLCustomShaderStage* stage)
-{
- if (customSrcStage)
- removeCustomStage();
- customSrcStage = stage;
- shaderProgNeedsChanging = true;
-}
-
-void QGLEngineShaderManager::removeCustomStage()
-{
- if (customSrcStage)
- customSrcStage->setInactive();
- customSrcStage = 0;
- shaderProgNeedsChanging = true;
-}
-
-QGLShaderProgram* QGLEngineShaderManager::currentProgram()
-{
- if (currentShaderProg)
- return currentShaderProg->program;
- else
- return sharedShaders->simpleProgram();
-}
-
-void QGLEngineShaderManager::useSimpleProgram()
-{
- sharedShaders->simpleProgram()->bind();
- QGLContextPrivate* ctx_d = ctx->d_func();
- ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
- ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
- ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
- shaderProgNeedsChanging = true;
-}
-
-void QGLEngineShaderManager::useBlitProgram()
-{
- sharedShaders->blitProgram()->bind();
- QGLContextPrivate* ctx_d = ctx->d_func();
- ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
- ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, true);
- ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
- shaderProgNeedsChanging = true;
-}
-
-QGLShaderProgram* QGLEngineShaderManager::simpleProgram()
-{
- return sharedShaders->simpleProgram();
-}
-
-QGLShaderProgram* QGLEngineShaderManager::blitProgram()
-{
- return sharedShaders->blitProgram();
-}
-
-
-
-// Select & use the correct shader program using the current state.
-// Returns \c true if program needed changing.
-bool QGLEngineShaderManager::useCorrectShaderProg()
-{
- if (!shaderProgNeedsChanging)
- return false;
-
- bool useCustomSrc = customSrcStage != 0;
- if (useCustomSrc && srcPixelType != QGLEngineShaderManager::ImageSrc && srcPixelType != Qt::TexturePattern) {
- useCustomSrc = false;
- qWarning("QGLEngineShaderManager - Ignoring custom shader stage for non image src");
- }
-
- QGLEngineShaderProg requiredProgram;
-
- bool texCoords = false;
-
- // Choose vertex shader shader position function (which typically also sets
- // varyings) and the source pixel (srcPixel) fragment shader function:
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::InvalidSnippetName;
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::InvalidSnippetName;
- bool isAffine = brushTransform.isAffine();
- if ( (srcPixelType >= Qt::Dense1Pattern) && (srcPixelType <= Qt::DiagCrossPattern) ) {
- if (isAffine)
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::AffinePositionWithPatternBrushVertexShader;
- else
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::PositionWithPatternBrushVertexShader;
-
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::PatternBrushSrcFragmentShader;
- }
- else switch (srcPixelType) {
- default:
- case Qt::NoBrush:
- qFatal("QGLEngineShaderManager::useCorrectShaderProg() - Qt::NoBrush style is set");
- break;
- case QGLEngineShaderManager::ImageSrc:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::ImageSrcFragmentShader;
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::PositionOnlyVertexShader;
- texCoords = true;
- break;
- case QGLEngineShaderManager::NonPremultipliedImageSrc:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::NonPremultipliedImageSrcFragmentShader;
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::PositionOnlyVertexShader;
- texCoords = true;
- break;
- case QGLEngineShaderManager::PatternSrc:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::ImageSrcWithPatternFragmentShader;
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::PositionOnlyVertexShader;
- texCoords = true;
- break;
- case QGLEngineShaderManager::TextureSrcWithPattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::TextureBrushSrcWithPatternFragmentShader;
- requiredProgram.positionVertexShader = isAffine ? QGLEngineSharedShaders::AffinePositionWithTextureBrushVertexShader
- : QGLEngineSharedShaders::PositionWithTextureBrushVertexShader;
- break;
- case Qt::SolidPattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::SolidBrushSrcFragmentShader;
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::PositionOnlyVertexShader;
- break;
- case Qt::LinearGradientPattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::LinearGradientBrushSrcFragmentShader;
- requiredProgram.positionVertexShader = isAffine ? QGLEngineSharedShaders::AffinePositionWithLinearGradientBrushVertexShader
- : QGLEngineSharedShaders::PositionWithLinearGradientBrushVertexShader;
- break;
- case Qt::ConicalGradientPattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::ConicalGradientBrushSrcFragmentShader;
- requiredProgram.positionVertexShader = isAffine ? QGLEngineSharedShaders::AffinePositionWithConicalGradientBrushVertexShader
- : QGLEngineSharedShaders::PositionWithConicalGradientBrushVertexShader;
- break;
- case Qt::RadialGradientPattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::RadialGradientBrushSrcFragmentShader;
- requiredProgram.positionVertexShader = isAffine ? QGLEngineSharedShaders::AffinePositionWithRadialGradientBrushVertexShader
- : QGLEngineSharedShaders::PositionWithRadialGradientBrushVertexShader;
- break;
- case Qt::TexturePattern:
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::TextureBrushSrcFragmentShader;
- requiredProgram.positionVertexShader = isAffine ? QGLEngineSharedShaders::AffinePositionWithTextureBrushVertexShader
- : QGLEngineSharedShaders::PositionWithTextureBrushVertexShader;
- break;
- };
-
- if (useCustomSrc) {
- requiredProgram.srcPixelFragShader = QGLEngineSharedShaders::CustomImageSrcFragmentShader;
- requiredProgram.customStageSource = customSrcStage->source();
- }
-
- const bool hasCompose = compositionMode > QPainter::CompositionMode_Plus;
- const bool hasMask = maskType != QGLEngineShaderManager::NoMask;
-
- // Choose fragment shader main function:
- if (opacityMode == AttributeOpacity) {
- Q_ASSERT(!hasCompose && !hasMask);
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_ImageArrays;
- } else {
- bool useGlobalOpacity = (opacityMode == UniformOpacity);
- if (hasCompose && hasMask && useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_CMO;
- if (hasCompose && hasMask && !useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_CM;
- if (!hasCompose && hasMask && useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_MO;
- if (!hasCompose && hasMask && !useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_M;
- if (hasCompose && !hasMask && useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_CO;
- if (hasCompose && !hasMask && !useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_C;
- if (!hasCompose && !hasMask && useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader_O;
- if (!hasCompose && !hasMask && !useGlobalOpacity)
- requiredProgram.mainFragShader = QGLEngineSharedShaders::MainFragmentShader;
- }
-
- if (hasMask) {
- if (maskType == PixelMask) {
- requiredProgram.maskFragShader = QGLEngineSharedShaders::MaskFragmentShader;
- texCoords = true;
- } else if (maskType == SubPixelMaskPass1) {
- requiredProgram.maskFragShader = QGLEngineSharedShaders::RgbMaskFragmentShaderPass1;
- texCoords = true;
- } else if (maskType == SubPixelMaskPass2) {
- requiredProgram.maskFragShader = QGLEngineSharedShaders::RgbMaskFragmentShaderPass2;
- texCoords = true;
- } else if (maskType == SubPixelWithGammaMask) {
- requiredProgram.maskFragShader = QGLEngineSharedShaders::RgbMaskWithGammaFragmentShader;
- texCoords = true;
- } else {
- qCritical("QGLEngineShaderManager::useCorrectShaderProg() - Unknown mask type");
- }
- } else {
- requiredProgram.maskFragShader = QGLEngineSharedShaders::NoMaskFragmentShader;
- }
-
- if (hasCompose) {
- switch (compositionMode) {
- case QPainter::CompositionMode_Multiply:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::MultiplyCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Screen:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::ScreenCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Overlay:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::OverlayCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Darken:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::DarkenCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Lighten:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::LightenCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_ColorDodge:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::ColorDodgeCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_ColorBurn:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::ColorBurnCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_HardLight:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::HardLightCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_SoftLight:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::SoftLightCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Difference:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::DifferenceCompositionModeFragmentShader;
- break;
- case QPainter::CompositionMode_Exclusion:
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::ExclusionCompositionModeFragmentShader;
- break;
- default:
- qWarning("QGLEngineShaderManager::useCorrectShaderProg() - Unsupported composition mode");
- }
- } else {
- requiredProgram.compositionFragShader = QGLEngineSharedShaders::NoCompositionModeFragmentShader;
- }
-
- // Choose vertex shader main function
- if (opacityMode == AttributeOpacity) {
- Q_ASSERT(texCoords);
- requiredProgram.mainVertexShader = QGLEngineSharedShaders::MainWithTexCoordsAndOpacityVertexShader;
- } else if (texCoords) {
- requiredProgram.mainVertexShader = QGLEngineSharedShaders::MainWithTexCoordsVertexShader;
- } else {
- requiredProgram.mainVertexShader = QGLEngineSharedShaders::MainVertexShader;
- }
- requiredProgram.useTextureCoords = texCoords;
- requiredProgram.useOpacityAttribute = (opacityMode == AttributeOpacity);
- if (complexGeometry && srcPixelType == Qt::SolidPattern) {
- requiredProgram.positionVertexShader = QGLEngineSharedShaders::ComplexGeometryPositionOnlyVertexShader;
- requiredProgram.usePmvMatrixAttribute = false;
- } else {
- requiredProgram.usePmvMatrixAttribute = true;
-
- // Force complexGeometry off, since we currently don't support that mode for
- // non-solid brushes
- complexGeometry = false;
- }
-
- // At this point, requiredProgram is fully populated so try to find the program in the cache
- currentShaderProg = sharedShaders->findProgramInCache(requiredProgram);
-
- if (currentShaderProg && useCustomSrc) {
- customSrcStage->setUniforms(currentShaderProg->program);
- }
-
- // Make sure all the vertex attribute arrays the program uses are enabled (and the ones it
- // doesn't use are disabled)
- QGLContextPrivate* ctx_d = ctx->d_func();
- ctx_d->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, true);
- ctx_d->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, currentShaderProg && currentShaderProg->useTextureCoords);
- ctx_d->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, currentShaderProg && currentShaderProg->useOpacityAttribute);
-
- shaderProgNeedsChanging = false;
- return true;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h b/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
deleted file mode 100644
index d23b3ad550..0000000000
--- a/src/opengl/gl2paintengineex/qglengineshadermanager_p.h
+++ /dev/null
@@ -1,508 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-/*
- VERTEX SHADERS
- ==============
-
- Vertex shaders are specified as multiple (partial) shaders. On desktop,
- this works fine. On ES, QGLShader & QGLShaderProgram will make partial
- shaders work by concatenating the source in each QGLShader and compiling
- it as a single shader. This is abstracted nicely by QGLShaderProgram and
- the GL2 engine doesn't need to worry about it.
-
- Generally, there's two vertex shader objects. The position shaders are
- the ones which set gl_Position. There's also two "main" vertex shaders,
- one which just calls the position shader and another which also passes
- through some texture coordinates from a vertex attribute array to a
- varying. These texture coordinates are used for mask position in text
- rendering and for the source coordinates in drawImage/drawPixmap. There's
- also a "Simple" vertex shader for rendering a solid colour (used to render
- into the stencil buffer where the actual colour value is discarded).
-
- The position shaders for brushes look scary. This is because many of the
- calculations which logically belong in the fragment shader have been moved
- into the vertex shader to improve performance. This is why the position
- calculation is in a separate shader. Not only does it calculate the
- position, but it also calculates some data to be passed to the fragment
- shader as a varying. It is optimal to move as much of the calculation as
- possible into the vertex shader as this is executed less often.
-
- The varyings passed to the fragment shaders are interpolated (which is
- cheap). Unfortunately, GL will apply perspective correction to the
- interpolation calusing errors. To get around this, the vertex shader must
- apply perspective correction itself and set the w-value of gl_Position to
- zero. That way, GL will be tricked into thinking it doesn't need to apply a
- perspective correction and use linear interpolation instead (which is what
- we want). Of course, if the brush transform is affeine, no perspective
- correction is needed and a simpler vertex shader can be used instead.
-
- So there are the following "main" vertex shaders:
- qglslMainVertexShader
- qglslMainWithTexCoordsVertexShader
-
- And the following position vertex shaders:
- qglslPositionOnlyVertexShader
- qglslPositionWithTextureBrushVertexShader
- qglslPositionWithPatternBrushVertexShader
- qglslPositionWithLinearGradientBrushVertexShader
- qglslPositionWithRadialGradientBrushVertexShader
- qglslPositionWithConicalGradientBrushVertexShader
- qglslAffinePositionWithTextureBrushVertexShader
- qglslAffinePositionWithPatternBrushVertexShader
- qglslAffinePositionWithLinearGradientBrushVertexShader
- qglslAffinePositionWithRadialGradientBrushVertexShader
- qglslAffinePositionWithConicalGradientBrushVertexShader
-
- Leading to 23 possible vertex shaders
-
-
- FRAGMENT SHADERS
- ================
-
- Fragment shaders are also specified as multiple (partial) shaders. The
- different fragment shaders represent the different stages in Qt's fragment
- pipeline. There are 1-3 stages in this pipeline: First stage is to get the
- fragment's colour value. The next stage is to get the fragment's mask value
- (coverage value for anti-aliasing) and the final stage is to blend the
- incoming fragment with the background (for composition modes not supported
- by GL).
-
- Of these, the first stage will always be present. If Qt doesn't need to
- apply anti-aliasing (because it's off or handled by multisampling) then
- the coverage value doesn't need to be applied. (Note: There are two types
- of mask, one for regular anti-aliasing and one for sub-pixel anti-
- aliasing.) If the composition mode is one which GL supports natively then
- the blending stage doesn't need to be applied.
-
- As eash stage can have multiple implementations, they are abstracted as
- GLSL function calls with the following signatures:
-
- Brushes & image drawing are implementations of "qcolorp vec4 srcPixel()":
- qglslImageSrcFragShader
- qglslImageSrcWithPatternFragShader
- qglslNonPremultipliedImageSrcFragShader
- qglslSolidBrushSrcFragShader
- qglslTextureBrushSrcFragShader
- qglslTextureBrushWithPatternFragShader
- qglslPatternBrushSrcFragShader
- qglslLinearGradientBrushSrcFragShader
- qglslRadialGradientBrushSrcFragShader
- qglslConicalGradientBrushSrcFragShader
- NOTE: It is assumed the colour returned by srcPixel() is pre-multiplied
-
- Masks are implementations of "qcolorp vec4 applyMask(qcolorp vec4 src)":
- qglslMaskFragmentShader
- qglslRgbMaskFragmentShaderPass1
- qglslRgbMaskFragmentShaderPass2
- qglslRgbMaskWithGammaFragmentShader
-
- Composition modes are "qcolorp vec4 compose(qcolorp vec4 src)":
- qglslColorBurnCompositionModeFragmentShader
- qglslColorDodgeCompositionModeFragmentShader
- qglslDarkenCompositionModeFragmentShader
- qglslDifferenceCompositionModeFragmentShader
- qglslExclusionCompositionModeFragmentShader
- qglslHardLightCompositionModeFragmentShader
- qglslLightenCompositionModeFragmentShader
- qglslMultiplyCompositionModeFragmentShader
- qglslOverlayCompositionModeFragmentShader
- qglslScreenCompositionModeFragmentShader
- qglslSoftLightCompositionModeFragmentShader
-
-
- Note: In the future, some GLSL compilers will support an extension allowing
- a new 'color' precision specifier. To support this, qcolorp is used for
- all color components so it can be defined to colorp or lowp depending upon
- the implementation.
-
- So there are differnt frament shader main functions, depending on the
- number & type of pipelines the fragment needs to go through.
-
- The choice of which main() fragment shader string to use depends on:
- - Use of global opacity
- - Brush style (some brushes apply opacity themselves)
- - Use & type of mask (TODO: Need to support high quality anti-aliasing & text)
- - Use of non-GL Composition mode
-
- Leading to the following fragment shader main functions:
- gl_FragColor = compose(applyMask(srcPixel()*globalOpacity));
- gl_FragColor = compose(applyMask(srcPixel()));
- gl_FragColor = applyMask(srcPixel()*globalOpacity);
- gl_FragColor = applyMask(srcPixel());
- gl_FragColor = compose(srcPixel()*globalOpacity);
- gl_FragColor = compose(srcPixel());
- gl_FragColor = srcPixel()*globalOpacity;
- gl_FragColor = srcPixel();
-
- Called:
- qglslMainFragmentShader_CMO
- qglslMainFragmentShader_CM
- qglslMainFragmentShader_MO
- qglslMainFragmentShader_M
- qglslMainFragmentShader_CO
- qglslMainFragmentShader_C
- qglslMainFragmentShader_O
- qglslMainFragmentShader
-
- Where:
- M = Mask
- C = Composition
- O = Global Opacity
-
-
- CUSTOM SHADER CODE
- ==================
-
- The use of custom shader code is supported by the engine for drawImage and
- drawPixmap calls. This is implemented via hooks in the fragment pipeline.
-
- The custom shader is passed to the engine as a partial fragment shader
- (QGLCustomShaderStage). The shader will implement a pre-defined method name
- which Qt's fragment pipeline will call:
-
- lowp vec4 customShader(lowp sampler2d imageTexture, highp vec2 textureCoords)
-
- The provided src and srcCoords parameters can be used to sample from the
- source image.
-
- Transformations, clipping, opacity, and composition modes set using QPainter
- will be respected when using the custom shader hook.
-*/
-
-#ifndef QGLENGINE_SHADER_MANAGER_H
-#define QGLENGINE_SHADER_MANAGER_H
-
-#include <QGLShader>
-#include <QGLShaderProgram>
-#include <QPainter>
-#include <private/qgl_p.h>
-#include <private/qglcustomshaderstage_p.h>
-
-QT_BEGIN_NAMESPACE
-
-
-
-/*
-struct QGLEngineCachedShaderProg
-{
- QGLEngineCachedShaderProg(QGLEngineShaderManager::ShaderName vertexMain,
- QGLEngineShaderManager::ShaderName vertexPosition,
- QGLEngineShaderManager::ShaderName fragMain,
- QGLEngineShaderManager::ShaderName pixelSrc,
- QGLEngineShaderManager::ShaderName mask,
- QGLEngineShaderManager::ShaderName composition);
-
- int cacheKey;
- QGLShaderProgram* program;
-}
-*/
-
-static const GLuint QT_VERTEX_COORDS_ATTR = 0;
-static const GLuint QT_TEXTURE_COORDS_ATTR = 1;
-static const GLuint QT_OPACITY_ATTR = 2;
-static const GLuint QT_PMV_MATRIX_1_ATTR = 3;
-static const GLuint QT_PMV_MATRIX_2_ATTR = 4;
-static const GLuint QT_PMV_MATRIX_3_ATTR = 5;
-
-class QGLEngineShaderProg;
-
-class Q_OPENGL_EXPORT QGLEngineSharedShaders
-{
- Q_GADGET
-public:
-
- enum SnippetName {
- MainVertexShader,
- MainWithTexCoordsVertexShader,
- MainWithTexCoordsAndOpacityVertexShader,
-
- // UntransformedPositionVertexShader must be first in the list:
- UntransformedPositionVertexShader,
- PositionOnlyVertexShader,
- ComplexGeometryPositionOnlyVertexShader,
- PositionWithPatternBrushVertexShader,
- PositionWithLinearGradientBrushVertexShader,
- PositionWithConicalGradientBrushVertexShader,
- PositionWithRadialGradientBrushVertexShader,
- PositionWithTextureBrushVertexShader,
- AffinePositionWithPatternBrushVertexShader,
- AffinePositionWithLinearGradientBrushVertexShader,
- AffinePositionWithConicalGradientBrushVertexShader,
- AffinePositionWithRadialGradientBrushVertexShader,
- AffinePositionWithTextureBrushVertexShader,
-
- // MainFragmentShader_CMO must be first in the list:
- MainFragmentShader_CMO,
- MainFragmentShader_CM,
- MainFragmentShader_MO,
- MainFragmentShader_M,
- MainFragmentShader_CO,
- MainFragmentShader_C,
- MainFragmentShader_O,
- MainFragmentShader,
- MainFragmentShader_ImageArrays,
-
- // ImageSrcFragmentShader must be first in the list::
- ImageSrcFragmentShader,
- ImageSrcWithPatternFragmentShader,
- NonPremultipliedImageSrcFragmentShader,
- CustomImageSrcFragmentShader,
- SolidBrushSrcFragmentShader,
- TextureBrushSrcFragmentShader,
- TextureBrushSrcWithPatternFragmentShader,
- PatternBrushSrcFragmentShader,
- LinearGradientBrushSrcFragmentShader,
- RadialGradientBrushSrcFragmentShader,
- ConicalGradientBrushSrcFragmentShader,
- ShockingPinkSrcFragmentShader,
-
- // NoMaskFragmentShader must be first in the list:
- NoMaskFragmentShader,
- MaskFragmentShader,
- RgbMaskFragmentShaderPass1,
- RgbMaskFragmentShaderPass2,
- RgbMaskWithGammaFragmentShader,
-
- // NoCompositionModeFragmentShader must be first in the list:
- NoCompositionModeFragmentShader,
- MultiplyCompositionModeFragmentShader,
- ScreenCompositionModeFragmentShader,
- OverlayCompositionModeFragmentShader,
- DarkenCompositionModeFragmentShader,
- LightenCompositionModeFragmentShader,
- ColorDodgeCompositionModeFragmentShader,
- ColorBurnCompositionModeFragmentShader,
- HardLightCompositionModeFragmentShader,
- SoftLightCompositionModeFragmentShader,
- DifferenceCompositionModeFragmentShader,
- ExclusionCompositionModeFragmentShader,
-
- TotalSnippetCount, InvalidSnippetName
- };
-#if defined (QT_DEBUG)
- Q_ENUMS(SnippetName)
- static QByteArray snippetNameStr(SnippetName snippetName);
-#endif
-
-/*
- // These allow the ShaderName enum to be used as a cache key
- const int mainVertexOffset = 0;
- const int positionVertexOffset = (1<<2) - PositionOnlyVertexShader;
- const int mainFragOffset = (1<<6) - MainFragmentShader_CMO;
- const int srcPixelOffset = (1<<10) - ImageSrcFragmentShader;
- const int maskOffset = (1<<14) - NoMaskShader;
- const int compositionOffset = (1 << 16) - MultiplyCompositionModeFragmentShader;
-*/
-
- QGLEngineSharedShaders(const QGLContext *context);
- ~QGLEngineSharedShaders();
-
- QGLShaderProgram *simpleProgram() { return simpleShaderProg; }
- QGLShaderProgram *blitProgram() { return blitShaderProg; }
- // Compile the program if it's not already in the cache, return the item in the cache.
- QGLEngineShaderProg *findProgramInCache(const QGLEngineShaderProg &prog);
- // Compile the custom shader if it's not already in the cache, return the item in the cache.
-
- static QGLEngineSharedShaders *shadersForContext(const QGLContext *context);
-
- // Ideally, this would be static and cleanup all programs in all contexts which
- // contain the custom code. Currently it is just a hint and we rely on deleted
- // custom shaders being cleaned up by being kicked out of the cache when it's
- // full.
- void cleanupCustomStage(QGLCustomShaderStage* stage);
-
-private:
- QGLShaderProgram *blitShaderProg;
- QGLShaderProgram *simpleShaderProg;
- QList<QGLEngineShaderProg*> cachedPrograms;
- QList<QGLShader *> shaders;
-
- static const char* qShaderSnippets[TotalSnippetCount];
-};
-
-
-class QGLEngineShaderProg
-{
-public:
- QGLEngineShaderProg() : program(nullptr) {}
-
- ~QGLEngineShaderProg() {
- if (program)
- delete program;
- }
-
- QGLEngineSharedShaders::SnippetName mainVertexShader;
- QGLEngineSharedShaders::SnippetName positionVertexShader;
- QGLEngineSharedShaders::SnippetName mainFragShader;
- QGLEngineSharedShaders::SnippetName srcPixelFragShader;
- QGLEngineSharedShaders::SnippetName maskFragShader;
- QGLEngineSharedShaders::SnippetName compositionFragShader;
-
- QByteArray customStageSource; //TODO: Decent cache key for custom stages
- QGLShaderProgram* program;
-
- QVector<uint> uniformLocations;
-
- bool useTextureCoords;
- bool useOpacityAttribute;
- bool usePmvMatrixAttribute;
-
- bool operator==(const QGLEngineShaderProg& other) const {
- // We don't care about the program
- return ( mainVertexShader == other.mainVertexShader &&
- positionVertexShader == other.positionVertexShader &&
- mainFragShader == other.mainFragShader &&
- srcPixelFragShader == other.srcPixelFragShader &&
- maskFragShader == other.maskFragShader &&
- compositionFragShader == other.compositionFragShader &&
- customStageSource == other.customStageSource
- );
- }
-};
-
-class Q_OPENGL_EXPORT QGLEngineShaderManager : public QObject
-{
- Q_OBJECT
-public:
- QGLEngineShaderManager(QGLContext* context);
- ~QGLEngineShaderManager();
-
- enum MaskType {NoMask, PixelMask, SubPixelMaskPass1, SubPixelMaskPass2, SubPixelWithGammaMask};
- enum PixelSrcType {
- ImageSrc = Qt::TexturePattern+1,
- NonPremultipliedImageSrc = Qt::TexturePattern+2,
- PatternSrc = Qt::TexturePattern+3,
- TextureSrcWithPattern = Qt::TexturePattern+4
- };
-
- enum Uniform {
- ImageTexture,
- PatternColor,
- GlobalOpacity,
- Depth,
- MaskTexture,
- FragmentColor,
- LinearData,
- Angle,
- HalfViewportSize,
- Fmp,
- Fmp2MRadius2,
- Inverse2Fmp2MRadius2,
- SqrFr,
- BRadius,
- InvertedTextureSize,
- BrushTransform,
- BrushTexture,
- Matrix,
- TranslateZ,
- NumUniforms
- };
-
- enum OpacityMode {
- NoOpacity,
- UniformOpacity,
- AttributeOpacity
- };
-
- // There are optimizations we can do, depending on the brush transform:
- // 1) May not have to apply perspective-correction
- // 2) Can use lower precision for matrix
- void optimiseForBrushTransform(QTransform::TransformationType transformType);
- void setSrcPixelType(Qt::BrushStyle);
- void setSrcPixelType(PixelSrcType); // For non-brush sources, like pixmaps & images
- void setOpacityMode(OpacityMode);
- void setMaskType(MaskType);
- void setCompositionMode(QPainter::CompositionMode);
- void setCustomStage(QGLCustomShaderStage* stage);
- void removeCustomStage();
-
- GLuint getUniformLocation(Uniform id);
-
- void setDirty(); // someone has manually changed the current shader program
- bool useCorrectShaderProg(); // returns true if the shader program needed to be changed
-
- void useSimpleProgram();
- void useBlitProgram();
- void setHasComplexGeometry(bool hasComplexGeometry)
- {
- complexGeometry = hasComplexGeometry;
- shaderProgNeedsChanging = true;
- }
- bool hasComplexGeometry() const
- {
- return complexGeometry;
- }
-
- QGLShaderProgram* currentProgram(); // Returns pointer to the shader the manager has chosen
- QGLShaderProgram* simpleProgram(); // Used to draw into e.g. stencil buffers
- QGLShaderProgram* blitProgram(); // Used to blit a texture into the framebuffer
-
- QGLEngineSharedShaders* sharedShaders;
-
-private:
- QGLContext* ctx;
- bool shaderProgNeedsChanging;
- bool complexGeometry;
-
- // Current state variables which influence the choice of shader:
- QTransform brushTransform;
- int srcPixelType;
- OpacityMode opacityMode;
- MaskType maskType;
- QPainter::CompositionMode compositionMode;
- QGLCustomShaderStage* customSrcStage;
-
- QGLEngineShaderProg* currentShaderProg;
-};
-
-QT_END_NAMESPACE
-
-#endif //QGLENGINE_SHADER_MANAGER_H
diff --git a/src/opengl/gl2paintengineex/qglengineshadersource_p.h b/src/opengl/gl2paintengineex/qglengineshadersource_p.h
deleted file mode 100644
index a667af9b96..0000000000
--- a/src/opengl/gl2paintengineex/qglengineshadersource_p.h
+++ /dev/null
@@ -1,523 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-
-#ifndef QGL_ENGINE_SHADER_SOURCE_H
-#define QGL_ENGINE_SHADER_SOURCE_H
-
-#include "qglengineshadermanager_p.h"
-
-QT_BEGIN_NAMESPACE
-
-
-
-static const char* const qglslMainVertexShader = "\n\
- void setPosition(); \n\
- void main(void) \n\
- { \n\
- setPosition(); \n\
- }\n";
-
-static const char* const qglslMainWithTexCoordsVertexShader = "\n\
- attribute highp vec2 textureCoordArray; \n\
- varying highp vec2 textureCoords; \n\
- void setPosition(); \n\
- void main(void) \n\
- { \n\
- setPosition(); \n\
- textureCoords = textureCoordArray; \n\
- }\n";
-
-static const char* const qglslMainWithTexCoordsAndOpacityVertexShader = "\n\
- attribute highp vec2 textureCoordArray; \n\
- attribute lowp float opacityArray; \n\
- varying highp vec2 textureCoords; \n\
- varying lowp float opacity; \n\
- void setPosition(); \n\
- void main(void) \n\
- { \n\
- setPosition(); \n\
- textureCoords = textureCoordArray; \n\
- opacity = opacityArray; \n\
- }\n";
-
-// NOTE: We let GL do the perspective correction so texture lookups in the fragment
-// shader are also perspective corrected.
-static const char* const qglslPositionOnlyVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray; \n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- void setPosition(void) \n\
- { \n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position = vec4(transformedPos.xy, 0.0, transformedPos.z); \n\
- }\n";
-
-static const char* const qglslComplexGeometryPositionOnlyVertexShader = "\n\
- uniform highp mat3 matrix; \n\
- uniform highp float translateZ; \n\
- attribute highp vec2 vertexCoordsArray; \n\
- void setPosition(void) \n\
- { \n\
- vec3 v = matrix * vec3(vertexCoordsArray, 1.0); \n\
- vec4 vz = mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, translateZ, 1) * vec4(v, 1.0); \n\
- gl_Position = vec4(vz.xyz, 1.0);\n\
- } \n";
-
-static const char* const qglslUntransformedPositionVertexShader = "\n\
- attribute highp vec4 vertexCoordsArray; \n\
- void setPosition(void) \n\
- { \n\
- gl_Position = vertexCoordsArray; \n\
- }\n";
-
-// Pattern Brush - This assumes the texture size is 8x8 and thus, the inverted size is 0.125
-static const char* const qglslPositionWithPatternBrushVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray; \n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- uniform mediump vec2 halfViewportSize; \n\
- uniform highp vec2 invertedTextureSize; \n\
- uniform highp mat3 brushTransform; \n\
- varying highp vec2 patternTexCoords; \n\
- void setPosition(void) \n\
- { \n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
- mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
- mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1.0); \n\
- mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
- gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
- patternTexCoords.xy = (hTexCoords.xy * 0.125) * invertedHTexCoordsZ; \n\
- }\n";
-
-static const char* const qglslAffinePositionWithPatternBrushVertexShader
- = qglslPositionWithPatternBrushVertexShader;
-
-static const char* const qglslPatternBrushSrcFragmentShader = "\n\
- uniform sampler2D brushTexture; \n\
- uniform lowp vec4 patternColor; \n\
- varying highp vec2 patternTexCoords;\n\
- lowp vec4 srcPixel() \n\
- { \n\
- return patternColor * (1.0 - texture2D(brushTexture, patternTexCoords).r); \n\
- }\n";
-
-
-// Linear Gradient Brush
-static const char* const qglslPositionWithLinearGradientBrushVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray; \n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- uniform mediump vec2 halfViewportSize; \n\
- uniform highp vec3 linearData; \n\
- uniform highp mat3 brushTransform; \n\
- varying mediump float index; \n\
- void setPosition() \n\
- { \n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
- mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
- mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
- mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
- gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
- index = (dot(linearData.xy, hTexCoords.xy) * linearData.z) * invertedHTexCoordsZ; \n\
- }\n";
-
-static const char* const qglslAffinePositionWithLinearGradientBrushVertexShader
- = qglslPositionWithLinearGradientBrushVertexShader;
-
-static const char* const qglslLinearGradientBrushSrcFragmentShader = "\n\
- uniform sampler2D brushTexture; \n\
- varying mediump float index; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- mediump vec2 val = vec2(index, 0.5); \n\
- return texture2D(brushTexture, val); \n\
- }\n";
-
-
-// Conical Gradient Brush
-static const char* const qglslPositionWithConicalGradientBrushVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray; \n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- uniform mediump vec2 halfViewportSize; \n\
- uniform highp mat3 brushTransform; \n\
- varying highp vec2 A; \n\
- void setPosition(void) \n\
- { \n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
- mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
- mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
- mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
- gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
- A = hTexCoords.xy * invertedHTexCoordsZ; \n\
- }\n";
-
-static const char* const qglslAffinePositionWithConicalGradientBrushVertexShader
- = qglslPositionWithConicalGradientBrushVertexShader;
-
-static const char* const qglslConicalGradientBrushSrcFragmentShader = "\n\
- #define INVERSE_2PI 0.1591549430918953358 \n\
- uniform sampler2D brushTexture; \n\
- uniform mediump float angle; \n\
- varying highp vec2 A; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- highp float t; \n\
- if (abs(A.y) == abs(A.x)) \n\
- t = (atan(-A.y + 0.002, A.x) + angle) * INVERSE_2PI; \n\
- else \n\
- t = (atan(-A.y, A.x) + angle) * INVERSE_2PI; \n\
- return texture2D(brushTexture, vec2(t - floor(t), 0.5)); \n\
- }\n";
-
-
-// Radial Gradient Brush
-static const char* const qglslPositionWithRadialGradientBrushVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray;\n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- uniform mediump vec2 halfViewportSize; \n\
- uniform highp mat3 brushTransform; \n\
- uniform highp vec2 fmp; \n\
- uniform mediump vec3 bradius; \n\
- varying highp float b; \n\
- varying highp vec2 A; \n\
- void setPosition(void) \n\
- {\n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
- mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
- mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
- mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
- gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
- A = hTexCoords.xy * invertedHTexCoordsZ; \n\
- b = bradius.x + 2.0 * dot(A, fmp); \n\
- }\n";
-
-static const char* const qglslAffinePositionWithRadialGradientBrushVertexShader
- = qglslPositionWithRadialGradientBrushVertexShader;
-
-static const char* const qglslRadialGradientBrushSrcFragmentShader = "\n\
- uniform sampler2D brushTexture; \n\
- uniform highp float fmp2_m_radius2; \n\
- uniform highp float inverse_2_fmp2_m_radius2; \n\
- uniform highp float sqrfr; \n\
- varying highp float b; \n\
- varying highp vec2 A; \n\
- uniform mediump vec3 bradius; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- highp float c = sqrfr-dot(A, A); \n\
- highp float det = b*b - 4.0*fmp2_m_radius2*c; \n\
- lowp vec4 result = vec4(0.0); \n\
- if (det >= 0.0) { \n\
- highp float detSqrt = sqrt(det); \n\
- highp float w = max((-b - detSqrt) * inverse_2_fmp2_m_radius2, (-b + detSqrt) * inverse_2_fmp2_m_radius2); \n\
- if (bradius.y + w * bradius.z >= 0.0) \n\
- result = texture2D(brushTexture, vec2(w, 0.5)); \n\
- } \n\
- return result; \n\
- }\n";
-
-
-// Texture Brush
-static const char* const qglslPositionWithTextureBrushVertexShader = "\n\
- attribute highp vec2 vertexCoordsArray; \n\
- attribute highp vec3 pmvMatrix1; \n\
- attribute highp vec3 pmvMatrix2; \n\
- attribute highp vec3 pmvMatrix3; \n\
- uniform mediump vec2 halfViewportSize; \n\
- uniform highp vec2 invertedTextureSize; \n\
- uniform highp mat3 brushTransform; \n\
- varying highp vec2 brushTextureCoords; \n\
- void setPosition(void) \n\
- { \n\
- highp mat3 pmvMatrix = mat3(pmvMatrix1, pmvMatrix2, pmvMatrix3); \n\
- vec3 transformedPos = pmvMatrix * vec3(vertexCoordsArray.xy, 1.0); \n\
- gl_Position.xy = transformedPos.xy / transformedPos.z; \n\
- mediump vec2 viewportCoords = (gl_Position.xy + 1.0) * halfViewportSize; \n\
- mediump vec3 hTexCoords = brushTransform * vec3(viewportCoords, 1); \n\
- mediump float invertedHTexCoordsZ = 1.0 / hTexCoords.z; \n\
- gl_Position = vec4(gl_Position.xy * invertedHTexCoordsZ, 0.0, invertedHTexCoordsZ); \n\
- brushTextureCoords.xy = (hTexCoords.xy * invertedTextureSize) * gl_Position.w; \n\
- }\n";
-
-static const char* const qglslAffinePositionWithTextureBrushVertexShader
- = qglslPositionWithTextureBrushVertexShader;
-
-// OpenGL ES does not support GL_REPEAT wrap modes for NPOT textures. So instead,
-// we emulate GL_REPEAT by only taking the fractional part of the texture coords.
-// TODO: Special case POT textures which don't need this emulation
-static const char* const qglslTextureBrushSrcFragmentShader_ES = "\n\
- varying highp vec2 brushTextureCoords; \n\
- uniform sampler2D brushTexture; \n\
- lowp vec4 srcPixel() { \n\
- return texture2D(brushTexture, fract(brushTextureCoords)); \n\
- }\n";
-
-static const char* const qglslTextureBrushSrcFragmentShader_desktop = "\n\
- varying highp vec2 brushTextureCoords; \n\
- uniform sampler2D brushTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- return texture2D(brushTexture, brushTextureCoords); \n\
- }\n";
-
-static const char* const qglslTextureBrushSrcWithPatternFragmentShader = "\n\
- varying highp vec2 brushTextureCoords; \n\
- uniform lowp vec4 patternColor; \n\
- uniform sampler2D brushTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- return patternColor * (1.0 - texture2D(brushTexture, brushTextureCoords).r); \n\
- }\n";
-
-// Solid Fill Brush
-static const char* const qglslSolidBrushSrcFragmentShader = "\n\
- uniform lowp vec4 fragmentColor; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- return fragmentColor; \n\
- }\n";
-
-static const char* const qglslImageSrcFragmentShader = "\n\
- varying highp vec2 textureCoords; \n\
- uniform sampler2D imageTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n"
- "return texture2D(imageTexture, textureCoords); \n"
- "}\n";
-
-static const char* const qglslCustomSrcFragmentShader = "\n\
- varying highp vec2 textureCoords; \n\
- uniform sampler2D imageTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- return customShader(imageTexture, textureCoords); \n\
- }\n";
-
-static const char* const qglslImageSrcWithPatternFragmentShader = "\n\
- varying highp vec2 textureCoords; \n\
- uniform lowp vec4 patternColor; \n\
- uniform sampler2D imageTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- return patternColor * (1.0 - texture2D(imageTexture, textureCoords).r); \n\
- }\n";
-
-static const char* const qglslNonPremultipliedImageSrcFragmentShader = "\n\
- varying highp vec2 textureCoords; \n\
- uniform sampler2D imageTexture; \n\
- lowp vec4 srcPixel() \n\
- { \n\
- lowp vec4 sample = texture2D(imageTexture, textureCoords); \n\
- sample.rgb = sample.rgb * sample.a; \n\
- return sample; \n\
- }\n";
-
-static const char* const qglslShockingPinkSrcFragmentShader = "\n\
- lowp vec4 srcPixel() \n\
- { \n\
- return vec4(0.98, 0.06, 0.75, 1.0); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_ImageArrays = "\n\
- varying lowp float opacity; \n\
- lowp vec4 srcPixel(); \n\
- void main() \n\
- { \n\
- gl_FragColor = srcPixel() * opacity; \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_CMO = "\n\
- uniform lowp float globalOpacity; \n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 applyMask(lowp vec4); \n\
- lowp vec4 compose(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = applyMask(compose(srcPixel()*globalOpacity))); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_CM = "\n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 applyMask(lowp vec4); \n\
- lowp vec4 compose(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = applyMask(compose(srcPixel())); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_MO = "\n\
- uniform lowp float globalOpacity; \n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 applyMask(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = applyMask(srcPixel()*globalOpacity); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_M = "\n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 applyMask(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = applyMask(srcPixel()); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_CO = "\n\
- uniform lowp float globalOpacity; \n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 compose(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = compose(srcPixel()*globalOpacity); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_C = "\n\
- lowp vec4 srcPixel(); \n\
- lowp vec4 compose(lowp vec4); \n\
- void main() \n\
- { \n\
- gl_FragColor = compose(srcPixel()); \n\
- }\n";
-
-static const char* const qglslMainFragmentShader_O = "\n\
- uniform lowp float globalOpacity; \n\
- lowp vec4 srcPixel(); \n\
- void main() \n\
- { \n\
- gl_FragColor = srcPixel()*globalOpacity; \n\
- }\n";
-
-static const char* const qglslMainFragmentShader = "\n\
- lowp vec4 srcPixel(); \n\
- void main() \n\
- { \n\
- gl_FragColor = srcPixel(); \n\
- }\n";
-
-static const char* const qglslMaskFragmentShader = "\n\
- varying highp vec2 textureCoords;\n\
- uniform sampler2D maskTexture;\n\
- lowp vec4 applyMask(lowp vec4 src) \n\
- {\n\
- lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
- return src * mask.a; \n\
- }\n";
-
-// For source over with subpixel antialiasing, the final color is calculated per component as follows
-// (.a is alpha component, .c is red, green or blue component):
-// alpha = src.a * mask.c * opacity
-// dest.c = dest.c * (1 - alpha) + src.c * alpha
-//
-// In the first pass, calculate: dest.c = dest.c * (1 - alpha) with blend funcs: zero, 1 - source color
-// In the second pass, calculate: dest.c = dest.c + src.c * alpha with blend funcs: one, one
-//
-// If source is a solid color (src is constant), only the first pass is needed, with blend funcs: constant, 1 - source color
-
-// For source composition with subpixel antialiasing, the final color is calculated per component as follows:
-// alpha = src.a * mask.c * opacity
-// dest.c = dest.c * (1 - mask.c) + src.c * alpha
-//
-
-static const char* const qglslRgbMaskFragmentShaderPass1 = "\n\
- varying highp vec2 textureCoords;\n\
- uniform sampler2D maskTexture;\n\
- lowp vec4 applyMask(lowp vec4 src) \n\
- { \n\
- lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
- return src.a * mask; \n\
- }\n";
-
-static const char* const qglslRgbMaskFragmentShaderPass2 = "\n\
- varying highp vec2 textureCoords;\n\
- uniform sampler2D maskTexture;\n\
- lowp vec4 applyMask(lowp vec4 src) \n\
- { \n\
- lowp vec4 mask = texture2D(maskTexture, textureCoords); \n\
- return src * mask; \n\
- }\n";
-
-/*
- Left to implement:
- RgbMaskFragmentShader,
- RgbMaskWithGammaFragmentShader,
-
- MultiplyCompositionModeFragmentShader,
- ScreenCompositionModeFragmentShader,
- OverlayCompositionModeFragmentShader,
- DarkenCompositionModeFragmentShader,
- LightenCompositionModeFragmentShader,
- ColorDodgeCompositionModeFragmentShader,
- ColorBurnCompositionModeFragmentShader,
- HardLightCompositionModeFragmentShader,
- SoftLightCompositionModeFragmentShader,
- DifferenceCompositionModeFragmentShader,
- ExclusionCompositionModeFragmentShader,
-*/
-
-QT_END_NAMESPACE
-
-#endif // GLGC_SHADER_SOURCE_H
diff --git a/src/opengl/gl2paintengineex/qglgradientcache.cpp b/src/opengl/gl2paintengineex/qglgradientcache.cpp
deleted file mode 100644
index fc5e236ca6..0000000000
--- a/src/opengl/gl2paintengineex/qglgradientcache.cpp
+++ /dev/null
@@ -1,225 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qglgradientcache_p.h"
-#include <private/qdrawhelper_p.h>
-#include <private/qgl_p.h>
-#include <QtCore/qmutex.h>
-#include <QtCore/qrandom.h>
-
-QT_BEGIN_NAMESPACE
-
-class QGL2GradientCacheWrapper
-{
-public:
- QGL2GradientCache *cacheForContext(const QGLContext *context) {
- QMutexLocker lock(&m_mutex);
- return m_resource.value<QGL2GradientCache>(context->contextHandle());
- }
-
-private:
- QOpenGLMultiGroupSharedResource m_resource;
- QMutex m_mutex;
-};
-
-Q_GLOBAL_STATIC(QGL2GradientCacheWrapper, qt_gradient_caches)
-
-QGL2GradientCache::QGL2GradientCache(QOpenGLContext *ctx)
- : QOpenGLSharedResource(ctx->shareGroup())
-{
-}
-
-QGL2GradientCache::~QGL2GradientCache()
-{
- cache.clear();
-}
-
-QGL2GradientCache *QGL2GradientCache::cacheForContext(const QGLContext *context)
-{
- return qt_gradient_caches()->cacheForContext(context);
-}
-
-void QGL2GradientCache::invalidateResource()
-{
- QMutexLocker lock(&m_mutex);
- cache.clear();
-}
-
-void QGL2GradientCache::freeResource(QOpenGLContext *)
-{
- cleanCache();
-}
-
-void QGL2GradientCache::cleanCache()
-{
- QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
- QMutexLocker lock(&m_mutex);
- QGLGradientColorTableHash::const_iterator it = cache.constBegin();
- for (; it != cache.constEnd(); ++it) {
- const CacheInfo &cache_info = it.value();
- funcs->glDeleteTextures(1, &cache_info.texId);
- }
- cache.clear();
-}
-
-GLuint QGL2GradientCache::getBuffer(const QGradient &gradient, qreal opacity)
-{
- QMutexLocker lock(&m_mutex);
- quint64 hash_val = 0;
-
- const QGradientStops stops = gradient.stops();
- for (int i = 0; i < stops.size() && i <= 2; i++)
- hash_val += stops[i].second.rgba();
-
- QGLGradientColorTableHash::const_iterator it = cache.constFind(hash_val);
-
- if (it == cache.constEnd())
- return addCacheElement(hash_val, gradient, opacity);
- else {
- do {
- const CacheInfo &cache_info = it.value();
- if (cache_info.stops == stops && cache_info.opacity == opacity
- && cache_info.interpolationMode == gradient.interpolationMode())
- {
- return cache_info.texId;
- }
- ++it;
- } while (it != cache.constEnd() && it.key() == hash_val);
- // an exact match for these stops and opacity was not found, create new cache
- return addCacheElement(hash_val, gradient, opacity);
- }
-}
-
-
-GLuint QGL2GradientCache::addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity)
-{
- QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
- if (cache.size() == maxCacheSize()) {
- int elem_to_remove = QRandomGenerator::global()->bounded(maxCacheSize());
- quint64 key = cache.keys()[elem_to_remove];
-
- // need to call glDeleteTextures on each removed cache entry:
- QGLGradientColorTableHash::const_iterator it = cache.constFind(key);
- do {
- funcs->glDeleteTextures(1, &it.value().texId);
- } while (++it != cache.constEnd() && it.key() == key);
- cache.remove(key); // may remove more than 1, but OK
- }
-
- CacheInfo cache_entry(gradient.stops(), opacity, gradient.interpolationMode());
- uint buffer[1024];
- generateGradientColorTable(gradient, buffer, paletteSize(), opacity);
- funcs->glGenTextures(1, &cache_entry.texId);
- funcs->glBindTexture(GL_TEXTURE_2D, cache_entry.texId);
- funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, paletteSize(), 1,
- 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
- return cache.insert(hash_val, cache_entry).value().texId;
-}
-
-
-// GL's expects pixels in RGBA (when using GL_RGBA), bin-endian (ABGR on x86).
-// Qt always stores in ARGB reguardless of the byte-order the mancine uses.
-static inline uint qtToGlColor(uint c)
-{
- uint o;
-#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
- o = (c & 0xff00ff00) // alpha & green already in the right place
- | ((c >> 16) & 0x000000ff) // red
- | ((c << 16) & 0x00ff0000); // blue
-#else //Q_BIG_ENDIAN
- o = (c << 8)
- | ((c >> 24) & 0x000000ff);
-#endif // Q_BYTE_ORDER
- return o;
-}
-
-//TODO: Let GL generate the texture using an FBO
-void QGL2GradientCache::generateGradientColorTable(const QGradient& gradient, uint *colorTable, int size, qreal opacity) const
-{
- int pos = 0;
- const QGradientStops s = gradient.stops();
- bool colorInterpolation = (gradient.interpolationMode() == QGradient::ColorInterpolation);
-
- uint alpha = qRound(opacity * 256);
- // Qt LIES! It returns ARGB (on little-endian AND on big-endian)
- uint current_color = ARGB_COMBINE_ALPHA(s[0].second.rgba(), alpha);
- qreal incr = 1.0 / qreal(size);
- qreal fpos = 1.5 * incr;
- colorTable[pos++] = qtToGlColor(qPremultiply(current_color));
-
- while (fpos <= s.first().first) {
- colorTable[pos] = colorTable[pos - 1];
- pos++;
- fpos += incr;
- }
-
- if (colorInterpolation)
- current_color = qPremultiply(current_color);
-
- const int sLast = s.size() - 1;
- for (int i = 0; i < sLast; ++i) {
- qreal delta = 1/(s[i+1].first - s[i].first);
- uint next_color = ARGB_COMBINE_ALPHA(s[i + 1].second.rgba(), alpha);
- if (colorInterpolation)
- next_color = qPremultiply(next_color);
-
- while (fpos < s[i+1].first && pos < size) {
- int dist = int(256 * ((fpos - s[i].first) * delta));
- int idist = 256 - dist;
- if (colorInterpolation)
- colorTable[pos] = qtToGlColor(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist));
- else
- colorTable[pos] = qtToGlColor(qPremultiply(INTERPOLATE_PIXEL_256(current_color, idist, next_color, dist)));
- ++pos;
- fpos += incr;
- }
- current_color = next_color;
- }
-
- Q_ASSERT(s.size() > 0);
-
- uint last_color = qtToGlColor(qPremultiply(ARGB_COMBINE_ALPHA(s[sLast].second.rgba(), alpha)));
- for (;pos < size; ++pos)
- colorTable[pos] = last_color;
-
- // Make sure the last color stop is represented at the end of the table
- colorTable[size-1] = last_color;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qglgradientcache_p.h b/src/opengl/gl2paintengineex/qglgradientcache_p.h
deleted file mode 100644
index 3c9da982e9..0000000000
--- a/src/opengl/gl2paintengineex/qglgradientcache_p.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGLGRADIENTCACHE_P_H
-#define QGLGRADIENTCACHE_P_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QMultiHash>
-#include <QObject>
-#include <QtOpenGL/QtOpenGL>
-#include <private/qgl_p.h>
-#include <QtCore/qmutex.h>
-
-QT_BEGIN_NAMESPACE
-
-class QGL2GradientCache : public QOpenGLSharedResource
-{
- struct CacheInfo
- {
- inline CacheInfo(QGradientStops s, qreal op, QGradient::InterpolationMode mode) :
- stops(s), opacity(op), interpolationMode(mode) {}
-
- GLuint texId;
- QGradientStops stops;
- qreal opacity;
- QGradient::InterpolationMode interpolationMode;
- };
-
- typedef QMultiHash<quint64, CacheInfo> QGLGradientColorTableHash;
-
-public:
- static QGL2GradientCache *cacheForContext(const QGLContext *context);
-
- QGL2GradientCache(QOpenGLContext *);
- ~QGL2GradientCache();
-
- GLuint getBuffer(const QGradient &gradient, qreal opacity);
- inline int paletteSize() const { return 1024; }
-
- void invalidateResource() override;
- void freeResource(QOpenGLContext *ctx) override;
-
-private:
- inline int maxCacheSize() const { return 60; }
- inline void generateGradientColorTable(const QGradient& gradient,
- uint *colorTable,
- int size, qreal opacity) const;
- GLuint addCacheElement(quint64 hash_val, const QGradient &gradient, qreal opacity);
- void cleanCache();
-
- QGLGradientColorTableHash cache;
- QMutex m_mutex;
-};
-
-QT_END_NAMESPACE
-
-#endif // QGLGRADIENTCACHE_P_H
diff --git a/src/opengl/gl2paintengineex/qglshadercache_p.h b/src/opengl/gl2paintengineex/qglshadercache_p.h
deleted file mode 100644
index 4204e3e256..0000000000
--- a/src/opengl/gl2paintengineex/qglshadercache_p.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#ifndef QGLSHADERCACHE_P_H
-#define QGLSHADERCACHE_P_H
-
-#include <QtCore/qglobal.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class QGLShaderProgram;
-class QGLContext;
-
-class CachedShader
-{
-public:
- inline CachedShader(const QByteArray &, const QByteArray &)
- {}
-
- inline bool isCached()
- {
- return false;
- }
-
- inline bool load(QGLShaderProgram *, const QGLContext *)
- {
- return false;
- }
-
- inline bool store(QGLShaderProgram *, const QGLContext *)
- {
- return false;
- }
-};
-
-QT_END_NAMESPACE
-
-#endif
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp b/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
deleted file mode 100644
index 2546f6dc13..0000000000
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2.cpp
+++ /dev/null
@@ -1,2515 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*
- When the active program changes, we need to update it's uniforms.
- We could track state for each program and only update stale uniforms
- - Could lead to lots of overhead if there's a lot of programs
- We could update all the uniforms when the program changes
- - Could end up updating lots of uniforms which don't need updating
-
- Updating uniforms should be cheap, so the overhead of updating up-to-date
- uniforms should be minimal. It's also less complex.
-
- Things which _may_ cause a different program to be used:
- - Change in brush/pen style
- - Change in painter opacity
- - Change in composition mode
-
- Whenever we set a mode on the shader manager - it needs to tell us if it had
- to switch to a different program.
-
- The shader manager should only switch when we tell it to. E.g. if we set a new
- brush style and then switch to transparent painter, we only want it to compile
- and use the correct program when we really need it.
-*/
-
-// #define QT_OPENGL_CACHE_AS_VBOS
-
-#include "qglgradientcache_p.h"
-#include "qpaintengineex_opengl2_p.h"
-
-#include <string.h> //for memcpy
-#include <qmath.h>
-
-#include <private/qgl_p.h>
-#include <private/qpaintengineex_p.h>
-#include <QPaintEngine>
-#include <private/qpainter_p.h>
-#include <private/qfontengine_p.h>
-#include <private/qdatabuffer_p.h>
-#include <private/qstatictext_p.h>
-#include <QtGui/private/qtriangulator_p.h>
-
-#include "qglengineshadermanager_p.h"
-#include "qgl2pexvertexarray_p.h"
-#include "qtextureglyphcache_gl_p.h"
-
-#include <QDebug>
-
-#ifndef QT_OPENGL_ES_2
-# include <qopenglfunctions_1_1.h>
-#endif
-
-QT_BEGIN_NAMESPACE
-
-
-
-Q_GUI_EXPORT QImage qt_imageForBrush(int brushStyle, bool invert);
-
-////////////////////////////////// Private Methods //////////////////////////////////////////
-
-QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate()
-{
- delete shaderManager;
-
- while (pathCaches.size()) {
- QVectorPath::CacheEntry *e = *(pathCaches.constBegin());
- e->cleanup(e->engine, e->data);
- e->data = 0;
- e->engine = 0;
- }
-
- if (elementIndicesVBOId != 0) {
- glDeleteBuffers(1, &elementIndicesVBOId);
- elementIndicesVBOId = 0;
- }
-}
-
-void QGL2PaintEngineExPrivate::updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id)
-{
-// glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT); //### Is it always this texture unit?
- if (id != GLuint(-1) && id == lastTextureUsed)
- return;
-
- lastTextureUsed = id;
-
- if (smoothPixmapTransform) {
- glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- } else {
- glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- }
- glTexParameteri(target, GL_TEXTURE_WRAP_S, wrapMode);
- glTexParameteri(target, GL_TEXTURE_WRAP_T, wrapMode);
-}
-
-
-inline QColor qt_premultiplyColor(QColor c, GLfloat opacity)
-{
- qreal alpha = c.alphaF() * opacity;
- c.setAlphaF(alpha);
- c.setRedF(c.redF() * alpha);
- c.setGreenF(c.greenF() * alpha);
- c.setBlueF(c.blueF() * alpha);
- return c;
-}
-
-
-void QGL2PaintEngineExPrivate::setBrush(const QBrush& brush)
-{
- if (qbrush_fast_equals(currentBrush, brush))
- return;
-
- const Qt::BrushStyle newStyle = qbrush_style(brush);
- Q_ASSERT(newStyle != Qt::NoBrush);
-
- currentBrush = brush;
- if (!currentBrushPixmap.isNull())
- currentBrushPixmap = QPixmap();
- brushUniformsDirty = true; // All brushes have at least one uniform
-
- if (newStyle > Qt::SolidPattern)
- brushTextureDirty = true;
-
- if (currentBrush.style() == Qt::TexturePattern
- && qHasPixmapTexture(brush) && brush.texture().isQBitmap())
- {
- shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern);
- } else {
- shaderManager->setSrcPixelType(newStyle);
- }
- shaderManager->optimiseForBrushTransform(currentBrush.transform().type());
-}
-
-
-void QGL2PaintEngineExPrivate::useSimpleShader()
-{
- shaderManager->useSimpleProgram();
-
- if (matrixDirty)
- updateMatrix();
-}
-
-// ####TODO Properly #ifdef this class to use #define symbols actually defined
-// by OpenGL/ES includes
-#ifndef GL_MIRRORED_REPEAT_IBM
-#define GL_MIRRORED_REPEAT_IBM 0x8370
-#endif
-
-void QGL2PaintEngineExPrivate::updateBrushTexture()
-{
- Q_Q(QGL2PaintEngineEx);
-// qDebug("QGL2PaintEngineExPrivate::updateBrushTexture()");
- Qt::BrushStyle style = currentBrush.style();
-
- if ( (style >= Qt::Dense1Pattern) && (style <= Qt::DiagCrossPattern) ) {
- // Get the image data for the pattern
- QImage texImage = qt_imageForBrush(style, false);
-
- glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
- ctx->d_func()->bindTexture(texImage, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);
- updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
- }
- else if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {
- // Gradiant brush: All the gradiants use the same texture
-
- const QGradient* g = currentBrush.gradient();
-
- // We apply global opacity in the fragment shaders, so we always pass 1.0
- // for opacity to the cache.
- GLuint texId = QGL2GradientCache::cacheForContext(ctx)->getBuffer(*g, 1.0);
-
- glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
- glBindTexture(GL_TEXTURE_2D, texId);
-
- if (g->spread() == QGradient::RepeatSpread || g->type() == QGradient::ConicalGradient)
- updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);
- else if (g->spread() == QGradient::ReflectSpread)
- updateTextureFilter(GL_TEXTURE_2D, GL_MIRRORED_REPEAT_IBM, q->state()->renderHints & QPainter::SmoothPixmapTransform);
- else
- updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE, q->state()->renderHints & QPainter::SmoothPixmapTransform);
- }
- else if (style == Qt::TexturePattern) {
- currentBrushPixmap = currentBrush.texture();
-
- int max_texture_size = ctx->d_func()->maxTextureSize();
- if (currentBrushPixmap.width() > max_texture_size || currentBrushPixmap.height() > max_texture_size)
- currentBrushPixmap = currentBrushPixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
-
- GLuint wrapMode = GL_REPEAT;
- if (ctx->contextHandle()->isOpenGLES()) {
- // OpenGL ES does not support GL_REPEAT wrap modes for NPOT textures. So instead,
- // we emulate GL_REPEAT by only taking the fractional part of the texture coords
- // in the qopenglslTextureBrushSrcFragmentShader program.
- wrapMode = GL_CLAMP_TO_EDGE;
- }
-
- glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);
- QGLTexture *tex = ctx->d_func()->bindTexture(currentBrushPixmap, GL_TEXTURE_2D, GL_RGBA,
- QGLContext::InternalBindOption |
- QGLContext::CanFlipNativePixmapBindOption);
- updateTextureFilter(GL_TEXTURE_2D, wrapMode, q->state()->renderHints & QPainter::SmoothPixmapTransform);
- textureInvertedY = tex->options & QGLContext::InvertedYBindOption ? -1 : 1;
- }
- brushTextureDirty = false;
-}
-
-
-void QGL2PaintEngineExPrivate::updateBrushUniforms()
-{
-// qDebug("QGL2PaintEngineExPrivate::updateBrushUniforms()");
- Qt::BrushStyle style = currentBrush.style();
-
- if (style == Qt::NoBrush)
- return;
-
- QTransform brushQTransform = currentBrush.transform();
-
- if (style == Qt::SolidPattern) {
- QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::FragmentColor), col);
- }
- else {
- // All other brushes have a transform and thus need the translation point:
- QPointF translationPoint;
-
- if (style <= Qt::DiagCrossPattern) {
- QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
-
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
-
- QVector2D halfViewportSize(width*0.5, height*0.5);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
- }
- else if (style == Qt::LinearGradientPattern) {
- const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush.gradient());
-
- QPointF realStart = g->start();
- QPointF realFinal = g->finalStop();
- translationPoint = realStart;
-
- QPointF l = realFinal - realStart;
-
- QVector3D linearData(
- l.x(),
- l.y(),
- 1.0f / (l.x() * l.x() + l.y() * l.y())
- );
-
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::LinearData), linearData);
-
- QVector2D halfViewportSize(width*0.5, height*0.5);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
- }
- else if (style == Qt::ConicalGradientPattern) {
- const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush.gradient());
- translationPoint = g->center();
-
- GLfloat angle = -qDegreesToRadians(g->angle());
-
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Angle), angle);
-
- QVector2D halfViewportSize(width*0.5, height*0.5);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
- }
- else if (style == Qt::RadialGradientPattern) {
- const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush.gradient());
- QPointF realCenter = g->center();
- QPointF realFocal = g->focalPoint();
- qreal realRadius = g->centerRadius() - g->focalRadius();
- translationPoint = realFocal;
-
- QPointF fmp = realCenter - realFocal;
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp), fmp);
-
- GLfloat fmp2_m_radius2 = -fmp.x() * fmp.x() - fmp.y() * fmp.y() + realRadius*realRadius;
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Inverse2Fmp2MRadius2),
- GLfloat(1.0 / (2.0*fmp2_m_radius2)));
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::SqrFr),
- GLfloat(g->focalRadius() * g->focalRadius()));
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BRadius),
- GLfloat(2 * (g->centerRadius() - g->focalRadius()) * g->focalRadius()),
- g->focalRadius(),
- g->centerRadius() - g->focalRadius());
-
- QVector2D halfViewportSize(width*0.5, height*0.5);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
- }
- else if (style == Qt::TexturePattern) {
- const QPixmap& texPixmap = currentBrush.texture();
-
- if (qHasPixmapTexture(currentBrush) && currentBrush.texture().isQBitmap()) {
- QColor col = qt_premultiplyColor(currentBrush.color(), (GLfloat)q->state()->opacity);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
- }
-
- QSizeF invertedTextureSize(1.0 / texPixmap.width(), 1.0 / texPixmap.height());
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::InvertedTextureSize), invertedTextureSize);
-
- QVector2D halfViewportSize(width*0.5, height*0.5);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);
- }
- else
- qWarning("QGL2PaintEngineEx: Unimplemented fill style");
-
- const QPointF &brushOrigin = q->state()->brushOrigin;
- QTransform matrix = q->state()->matrix;
- matrix.translate(brushOrigin.x(), brushOrigin.y());
-
- QTransform translate(1, 0, 0, 1, -translationPoint.x(), -translationPoint.y());
- qreal m22 = -1;
- qreal dy = height;
- if (device->isFlipped()) {
- m22 = 1;
- dy = 0;
- }
- QTransform gl_to_qt(1, 0, 0, m22, 0, dy);
- QTransform inv_matrix;
- if (style == Qt::TexturePattern && textureInvertedY == -1)
- inv_matrix = gl_to_qt * (QTransform(1, 0, 0, -1, 0, currentBrush.texture().height()) * brushQTransform * matrix).inverted() * translate;
- else
- inv_matrix = gl_to_qt * (brushQTransform * matrix).inverted() * translate;
-
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTransform), inv_matrix);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTexture), QT_BRUSH_TEXTURE_UNIT);
- }
- brushUniformsDirty = false;
-}
-
-
-// This assumes the shader manager has already setup the correct shader program
-void QGL2PaintEngineExPrivate::updateMatrix()
-{
-// qDebug("QGL2PaintEngineExPrivate::updateMatrix()");
-
- const QTransform& transform = q->state()->matrix;
-
- // The projection matrix converts from Qt's coordinate system to GL's coordinate system
- // * GL's viewport is 2x2, Qt's is width x height
- // * GL has +y -> -y going from bottom -> top, Qt is the other way round
- // * GL has [0,0] in the center, Qt has it in the top-left
- //
- // This results in the Projection matrix below, which is multiplied by the painter's
- // transformation matrix, as shown below:
- //
- // Projection Matrix Painter Transform
- // ------------------------------------------------ ------------------------
- // | 2.0 / width | 0.0 | -1.0 | | m11 | m21 | dx |
- // | 0.0 | -2.0 / height | 1.0 | * | m12 | m22 | dy |
- // | 0.0 | 0.0 | 1.0 | | m13 | m23 | m33 |
- // ------------------------------------------------ ------------------------
- //
- // NOTE: The resultant matrix is also transposed, as GL expects column-major matracies
-
- const GLfloat wfactor = 2.0f / width;
- GLfloat hfactor = -2.0f / height;
-
- GLfloat dx = transform.dx();
- GLfloat dy = transform.dy();
-
- if (device->isFlipped()) {
- hfactor *= -1;
- dy -= height;
- }
-
- // Non-integer translates can have strange effects for some rendering operations such as
- // anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.
- if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {
- // 0.50 needs to rounded down to 0.0 for consistency with raster engine:
- dx = std::ceil(dx - 0.5f);
- dy = std::ceil(dy - 0.5f);
- }
- pmvMatrix[0][0] = (wfactor * transform.m11()) - transform.m13();
- pmvMatrix[1][0] = (wfactor * transform.m21()) - transform.m23();
- pmvMatrix[2][0] = (wfactor * dx) - transform.m33();
- pmvMatrix[0][1] = (hfactor * transform.m12()) + transform.m13();
- pmvMatrix[1][1] = (hfactor * transform.m22()) + transform.m23();
- pmvMatrix[2][1] = (hfactor * dy) + transform.m33();
- pmvMatrix[0][2] = transform.m13();
- pmvMatrix[1][2] = transform.m23();
- pmvMatrix[2][2] = transform.m33();
-
- // 1/10000 == 0.0001, so we have good enough res to cover curves
- // that span the entire widget...
- inverseScale = qMax(1 / qMax( qMax(qAbs(transform.m11()), qAbs(transform.m22())),
- qMax(qAbs(transform.m12()), qAbs(transform.m21())) ),
- qreal(0.0001));
-
- matrixDirty = false;
- matrixUniformDirty = true;
-
- // Set the PMV matrix attribute. As we use an attributes rather than uniforms, we only
- // need to do this once for every matrix change and persists across all shader programs.
- glVertexAttrib3fv(QT_PMV_MATRIX_1_ATTR, pmvMatrix[0]);
- glVertexAttrib3fv(QT_PMV_MATRIX_2_ATTR, pmvMatrix[1]);
- glVertexAttrib3fv(QT_PMV_MATRIX_3_ATTR, pmvMatrix[2]);
-
- dasher.setInvScale(inverseScale);
- stroker.setInvScale(inverseScale);
-}
-
-
-void QGL2PaintEngineExPrivate::updateCompositionMode()
-{
- // NOTE: The entire paint engine works on pre-multiplied data - which is why some of these
- // composition modes look odd.
-// qDebug() << "QGL2PaintEngineExPrivate::updateCompositionMode() - Setting GL composition mode for " << q->state()->composition_mode;
- switch(q->state()->composition_mode) {
- case QPainter::CompositionMode_SourceOver:
- glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_DestinationOver:
- glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
- break;
- case QPainter::CompositionMode_Clear:
- glBlendFunc(GL_ZERO, GL_ZERO);
- break;
- case QPainter::CompositionMode_Source:
- glBlendFunc(GL_ONE, GL_ZERO);
- break;
- case QPainter::CompositionMode_Destination:
- glBlendFunc(GL_ZERO, GL_ONE);
- break;
- case QPainter::CompositionMode_SourceIn:
- glBlendFunc(GL_DST_ALPHA, GL_ZERO);
- break;
- case QPainter::CompositionMode_DestinationIn:
- glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_SourceOut:
- glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
- break;
- case QPainter::CompositionMode_DestinationOut:
- glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_SourceAtop:
- glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_DestinationAtop:
- glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_Xor:
- glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case QPainter::CompositionMode_Plus:
- glBlendFunc(GL_ONE, GL_ONE);
- break;
- default:
- qWarning("Unsupported composition mode");
- break;
- }
-
- compositionModeDirty = false;
-}
-
-static inline void setCoords(GLfloat *coords, const QGLRect &rect)
-{
- coords[0] = rect.left;
- coords[1] = rect.top;
- coords[2] = rect.right;
- coords[3] = rect.top;
- coords[4] = rect.right;
- coords[5] = rect.bottom;
- coords[6] = rect.left;
- coords[7] = rect.bottom;
-}
-
-void QGL2PaintEngineExPrivate::drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern)
-{
- // Setup for texture drawing
- currentBrush = noBrush;
- shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc);
-
- if (snapToPixelGrid) {
- snapToPixelGrid = false;
- matrixDirty = true;
- }
-
- if (prepareForDraw(opaque))
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
-
- if (pattern) {
- QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
- }
-
- GLfloat dx = 1.0 / textureSize.width();
- GLfloat dy = 1.0 / textureSize.height();
-
- QGLRect srcTextureRect(src.left*dx, src.top*dy, src.right*dx, src.bottom*dy);
-
- setCoords(staticVertexCoordinateArray, dest);
- setCoords(staticTextureCoordinateArray, srcTextureRect);
-
- glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-}
-
-void QGL2PaintEngineEx::beginNativePainting()
-{
- Q_D(QGL2PaintEngineEx);
- ensureActive();
- d->transferMode(BrushDrawingMode);
-
- d->nativePaintingActive = true;
-
- d->glUseProgram(0);
-
- // Disable all the vertex attribute arrays:
- for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
- d->glDisableVertexAttribArray(i);
-
-#ifndef QT_OPENGL_ES_2
- if (!d->ctx->contextHandle()->isOpenGLES()) {
- const QGLContext *ctx = d->ctx;
- const QGLFormat &fmt = d->device->format();
- if (fmt.majorVersion() < 3 || (fmt.majorVersion() == 3 && fmt.minorVersion() < 1)
- || (fmt.majorVersion() == 3 && fmt.minorVersion() == 1 && ctx->contextHandle()->hasExtension(QByteArrayLiteral("GL_ARB_compatibility")))
- || fmt.profile() == QGLFormat::CompatibilityProfile)
- {
- // be nice to people who mix OpenGL 1.x code with QPainter commands
- // by setting modelview and projection matrices to mirror the GL 1
- // paint engine
- const QTransform& mtx = state()->matrix;
-
- float mv_matrix[4][4] =
- {
- { float(mtx.m11()), float(mtx.m12()), 0, float(mtx.m13()) },
- { float(mtx.m21()), float(mtx.m22()), 0, float(mtx.m23()) },
- { 0, 0, 1, 0 },
- { float(mtx.dx()), float(mtx.dy()), 0, float(mtx.m33()) }
- };
-
- const QSize sz = d->device->size();
-
- QOpenGLFunctions_1_1 *gl1funcs = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_1_1>();
- gl1funcs->initializeOpenGLFunctions();
-
- gl1funcs->glMatrixMode(GL_PROJECTION);
- gl1funcs->glLoadIdentity();
- gl1funcs->glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);
-
- gl1funcs->glMatrixMode(GL_MODELVIEW);
- gl1funcs->glLoadMatrixf(&mv_matrix[0][0]);
- }
- }
-#endif
-
- d->lastTextureUsed = GLuint(-1);
- d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
- d->resetGLState();
-
- d->shaderManager->setDirty();
-
- d->needsSync = true;
-}
-
-void QGL2PaintEngineExPrivate::resetGLState()
-{
- glDisable(GL_BLEND);
- glActiveTexture(GL_TEXTURE0);
- glDisable(GL_STENCIL_TEST);
- glDisable(GL_DEPTH_TEST);
- glDisable(GL_SCISSOR_TEST);
- glDepthMask(true);
- glDepthFunc(GL_LESS);
- glClearDepthf(1);
- glStencilMask(0xff);
- glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
- glStencilFunc(GL_ALWAYS, 0, 0xff);
- ctx->d_func()->setVertexAttribArrayEnabled(QT_TEXTURE_COORDS_ATTR, false);
- ctx->d_func()->setVertexAttribArrayEnabled(QT_VERTEX_COORDS_ATTR, false);
- ctx->d_func()->setVertexAttribArrayEnabled(QT_OPACITY_ATTR, false);
-#ifndef QT_OPENGL_ES_2
- if (!ctx->contextHandle()->isOpenGLES()) {
- // gl_Color, corresponding to vertex attribute 3, may have been changed
- float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
- glVertexAttrib4fv(3, color);
- }
-#endif
-}
-
-bool QGL2PaintEngineExPrivate::resetOpenGLContextActiveEngine()
-{
- QOpenGLContext *guiGlContext = ctx->contextHandle();
- QOpenGLContextPrivate *guiGlContextPrivate =
- guiGlContext ? QOpenGLContextPrivate::get(guiGlContext) : 0;
-
- if (guiGlContextPrivate && guiGlContextPrivate->active_engine) {
- ctx->d_func()->refreshCurrentFbo();
- guiGlContextPrivate->active_engine = 0;
- return true;
- }
-
- return false;
-}
-
-void QGL2PaintEngineEx::endNativePainting()
-{
- Q_D(QGL2PaintEngineEx);
- d->needsSync = true;
- d->nativePaintingActive = false;
-}
-
-void QGL2PaintEngineEx::invalidateState()
-{
- Q_D(QGL2PaintEngineEx);
- d->needsSync = true;
-}
-
-bool QGL2PaintEngineEx::isNativePaintingActive() const {
- Q_D(const QGL2PaintEngineEx);
- return d->nativePaintingActive;
-}
-
-bool QGL2PaintEngineEx::shouldDrawCachedGlyphs(QFontEngine *fontEngine, const QTransform &t) const
-{
- // The paint engine does not support projected cached glyph drawing
- if (t.type() == QTransform::TxProject)
- return false;
-
- // The font engine might not support filling the glyph cache
- // with the given transform applied, in which case we need to
- // fall back to the QPainterPath code-path.
- if (!fontEngine->supportsTransformation(t)) {
- // Except that drawing paths is slow, so for scales between
- // 0.5 and 2.0 we leave the glyph cache untransformed and deal
- // with the transform ourselves when painting, resulting in
- // drawing 1x cached glyphs with a smooth-scale.
- float det = t.determinant();
- if (det >= 0.25f && det <= 4.f) {
- // Assuming the baseclass still agrees
- return QPaintEngineEx::shouldDrawCachedGlyphs(fontEngine, t);
- }
-
- return false; // Fall back to path-drawing
- }
-
- return QPaintEngineEx::shouldDrawCachedGlyphs(fontEngine, t);
-}
-
-void QGL2PaintEngineExPrivate::transferMode(EngineMode newMode)
-{
- if (newMode == mode)
- return;
-
- if (mode == TextDrawingMode || mode == ImageDrawingMode || mode == ImageArrayDrawingMode) {
- lastTextureUsed = GLuint(-1);
- }
-
- if (newMode == TextDrawingMode) {
- shaderManager->setHasComplexGeometry(true);
- } else {
- shaderManager->setHasComplexGeometry(false);
- }
-
- if (newMode == ImageDrawingMode) {
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
- setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, staticTextureCoordinateArray);
- }
-
- if (newMode == ImageArrayDrawingMode) {
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinateArray.data());
- setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinateArray.data());
- setVertexAttributePointer(QT_OPACITY_ATTR, (GLfloat*)opacityArray.data());
- }
-
- // This needs to change when we implement high-quality anti-aliasing...
- if (newMode != TextDrawingMode)
- shaderManager->setMaskType(QGLEngineShaderManager::NoMask);
-
- mode = newMode;
-}
-
-struct QGL2PEVectorPathCache
-{
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- GLuint vbo;
- GLuint ibo;
-#else
- float *vertices;
- void *indices;
-#endif
- int vertexCount;
- int indexCount;
- GLenum primitiveType;
- qreal iscale;
- QVertexIndexVector::Type indexType;
-};
-
-void QGL2PaintEngineExPrivate::cleanupVectorPath(QPaintEngineEx *engine, void *data)
-{
- QGL2PEVectorPathCache *c = (QGL2PEVectorPathCache *) data;
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- Q_ASSERT(engine->type() == QPaintEngine::OpenGL2);
- static_cast<QGL2PaintEngineEx *>(engine)->d_func()->unusedVBOSToClean << c->vbo;
- if (c->ibo)
- d->unusedIBOSToClean << c->ibo;
-#else
- Q_UNUSED(engine);
- free(c->vertices);
- free(c->indices);
-#endif
- delete c;
-}
-
-// Assumes everything is configured for the brush you want to use
-void QGL2PaintEngineExPrivate::fill(const QVectorPath& path)
-{
- transferMode(BrushDrawingMode);
-
- if (snapToPixelGrid) {
- snapToPixelGrid = false;
- matrixDirty = true;
- }
-
- // Might need to call updateMatrix to re-calculate inverseScale
- if (matrixDirty)
- updateMatrix();
-
- const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
-
- // Check to see if there's any hints
- if (path.shape() == QVectorPath::RectangleHint) {
- QGLRect rect(points[0].x(), points[0].y(), points[2].x(), points[2].y());
- prepareForDraw(currentBrush.isOpaque());
- composite(rect);
- } else if (path.isConvex()) {
-
- if (path.isCacheable()) {
- QVectorPath::CacheEntry *data = path.lookupCacheData(q);
- QGL2PEVectorPathCache *cache;
-
- bool updateCache = false;
-
- if (data) {
- cache = (QGL2PEVectorPathCache *) data->data;
- // Check if scale factor is exceeded for curved paths and generate curves if so...
- if (path.isCurved()) {
- qreal scaleFactor = cache->iscale / inverseScale;
- if (scaleFactor < 0.5 || scaleFactor > 2.0) {
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glDeleteBuffers(1, &cache->vbo);
- cache->vbo = 0;
- Q_ASSERT(cache->ibo == 0);
-#else
- free(cache->vertices);
- Q_ASSERT(cache->indices == 0);
-#endif
- updateCache = true;
- }
- }
- } else {
- cache = new QGL2PEVectorPathCache;
- data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
- updateCache = true;
- }
-
- // Flatten the path at the current scale factor and fill it into the cache struct.
- if (updateCache) {
- vertexCoordinateArray.clear();
- vertexCoordinateArray.addPath(path, inverseScale, false);
- int vertexCount = vertexCoordinateArray.vertexCount();
- int floatSizeInBytes = vertexCount * 2 * sizeof(float);
- cache->vertexCount = vertexCount;
- cache->indexCount = 0;
- cache->primitiveType = GL_TRIANGLE_FAN;
- cache->iscale = inverseScale;
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glGenBuffers(1, &cache->vbo);
- glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
- glBufferData(GL_ARRAY_BUFFER, floatSizeInBytes, vertexCoordinateArray.data(), GL_STATIC_DRAW);
- cache->ibo = 0;
-#else
- cache->vertices = (float *) malloc(floatSizeInBytes);
- memcpy(cache->vertices, vertexCoordinateArray.data(), floatSizeInBytes);
- cache->indices = 0;
-#endif
- }
-
- prepareForDraw(currentBrush.isOpaque());
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
-#else
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
-#endif
- glDrawArrays(cache->primitiveType, 0, cache->vertexCount);
-
- } else {
- // printf(" - Marking path as cachable...\n");
- // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
- path.makeCacheable();
- vertexCoordinateArray.clear();
- vertexCoordinateArray.addPath(path, inverseScale, false);
- prepareForDraw(currentBrush.isOpaque());
- drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
- }
-
- } else {
- bool useCache = path.isCacheable();
- if (useCache) {
- QRectF bbox = path.controlPointRect();
- // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
- useCache &= (bbox.left() > -0x8000 * inverseScale)
- && (bbox.right() < 0x8000 * inverseScale)
- && (bbox.top() > -0x8000 * inverseScale)
- && (bbox.bottom() < 0x8000 * inverseScale);
- }
-
- if (useCache) {
- QVectorPath::CacheEntry *data = path.lookupCacheData(q);
- QGL2PEVectorPathCache *cache;
-
- bool updateCache = false;
-
- if (data) {
- cache = (QGL2PEVectorPathCache *) data->data;
- // Check if scale factor is exceeded for curved paths and generate curves if so...
- if (path.isCurved()) {
- qreal scaleFactor = cache->iscale / inverseScale;
- if (scaleFactor < 0.5 || scaleFactor > 2.0) {
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glDeleteBuffers(1, &cache->vbo);
- glDeleteBuffers(1, &cache->ibo);
-#else
- free(cache->vertices);
- free(cache->indices);
-#endif
- updateCache = true;
- }
- }
- } else {
- cache = new QGL2PEVectorPathCache;
- data = const_cast<QVectorPath &>(path).addCacheData(q, cache, cleanupVectorPath);
- updateCache = true;
- }
-
- // Flatten the path at the current scale factor and fill it into the cache struct.
- if (updateCache) {
- QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));
- cache->vertexCount = polys.vertices.size() / 2;
- cache->indexCount = polys.indices.size();
- cache->primitiveType = GL_TRIANGLES;
- cache->iscale = inverseScale;
- cache->indexType = polys.indices.type();
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glGenBuffers(1, &cache->vbo);
- glGenBuffers(1, &cache->ibo);
- glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
-
- if (polys.indices.type() == QVertexIndexVector::UnsignedInt)
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint32) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
- else
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(quint16) * polys.indices.size(), polys.indices.data(), GL_STATIC_DRAW);
-
- QVarLengthArray<float> vertices(polys.vertices.size());
- for (int i = 0; i < polys.vertices.size(); ++i)
- vertices[i] = float(inverseScale * polys.vertices.at(i));
- glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
-#else
- cache->vertices = (float *) malloc(sizeof(float) * polys.vertices.size());
- if (polys.indices.type() == QVertexIndexVector::UnsignedInt) {
- cache->indices = (quint32 *) malloc(sizeof(quint32) * polys.indices.size());
- memcpy(cache->indices, polys.indices.data(), sizeof(quint32) * polys.indices.size());
- } else {
- cache->indices = (quint16 *) malloc(sizeof(quint16) * polys.indices.size());
- memcpy(cache->indices, polys.indices.data(), sizeof(quint16) * polys.indices.size());
- }
- for (int i = 0; i < polys.vertices.size(); ++i)
- cache->vertices[i] = float(inverseScale * polys.vertices.at(i));
-#endif
- }
-
- prepareForDraw(currentBrush.isOpaque());
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- glBindBuffer(GL_ARRAY_BUFFER, cache->vbo);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cache->ibo);
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, 0);
- if (cache->indexType == QVertexIndexVector::UnsignedInt)
- glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, 0);
- else
- glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ARRAY_BUFFER, 0);
-#else
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, cache->vertices);
- if (cache->indexType == QVertexIndexVector::UnsignedInt)
- glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_INT, (qint32 *)cache->indices);
- else
- glDrawElements(cache->primitiveType, cache->indexCount, GL_UNSIGNED_SHORT, (qint16 *)cache->indices);
-#endif
-
- } else {
- // printf(" - Marking path as cachable...\n");
- // Tag it for later so that if the same path is drawn twice, it is assumed to be static and thus cachable
- path.makeCacheable();
-
- if (!device->format().stencil()) {
- // If there is no stencil buffer, triangulate the path instead.
-
- QRectF bbox = path.controlPointRect();
- // If the path doesn't fit within these limits, it is possible that the triangulation will fail.
- bool withinLimits = (bbox.left() > -0x8000 * inverseScale)
- && (bbox.right() < 0x8000 * inverseScale)
- && (bbox.top() > -0x8000 * inverseScale)
- && (bbox.bottom() < 0x8000 * inverseScale);
- if (withinLimits) {
- QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));
-
- QVarLengthArray<float> vertices(polys.vertices.size());
- for (int i = 0; i < polys.vertices.size(); ++i)
- vertices[i] = float(inverseScale * polys.vertices.at(i));
-
- prepareForDraw(currentBrush.isOpaque());
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, vertices.constData());
- if (polys.indices.type() == QVertexIndexVector::UnsignedInt)
- glDrawElements(GL_TRIANGLES, polys.indices.size(), GL_UNSIGNED_INT, polys.indices.data());
- else
- glDrawElements(GL_TRIANGLES, polys.indices.size(), GL_UNSIGNED_SHORT, polys.indices.data());
- } else {
- // We can't handle big, concave painter paths with OpenGL without stencil buffer.
- qWarning("Painter path exceeds +/-32767 pixels.");
- }
- return;
- }
-
- // The path is too complicated & needs the stencil technique
- vertexCoordinateArray.clear();
- vertexCoordinateArray.addPath(path, inverseScale, false);
-
- fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
-
- glStencilMask(0xff);
- glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
-
- if (q->state()->clipTestEnabled) {
- // Pass when high bit is set, replace stencil value with current clip
- glStencilFunc(GL_NOTEQUAL, q->state()->currentClip, GL_STENCIL_HIGH_BIT);
- } else if (path.hasWindingFill()) {
- // Pass when any bit is set, replace stencil value with 0
- glStencilFunc(GL_NOTEQUAL, 0, 0xff);
- } else {
- // Pass when high bit is set, replace stencil value with 0
- glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
- }
- prepareForDraw(currentBrush.isOpaque());
-
- // Stencil the brush onto the dest buffer
- composite(vertexCoordinateArray.boundingRect());
- glStencilMask(0);
- updateClipScissorTest();
- }
- }
-}
-
-
-void QGL2PaintEngineExPrivate::fillStencilWithVertexArray(const float *data,
- int count,
- int *stops,
- int stopCount,
- const QGLRect &bounds,
- StencilFillMode mode)
-{
- Q_ASSERT(count || stops);
-
-// qDebug("QGL2PaintEngineExPrivate::fillStencilWithVertexArray()");
- glStencilMask(0xff); // Enable stencil writes
-
- if (dirtyStencilRegion.intersects(currentScissorBounds)) {
- const QRegion clearRegion = dirtyStencilRegion.intersected(currentScissorBounds);
- glClearStencil(0); // Clear to zero
- for (const QRect &rect : clearRegion) {
-#ifndef QT_GL_NO_SCISSOR_TEST
- setScissor(rect);
-#endif
- glClear(GL_STENCIL_BUFFER_BIT);
- }
-
- dirtyStencilRegion -= currentScissorBounds;
-
-#ifndef QT_GL_NO_SCISSOR_TEST
- updateClipScissorTest();
-#endif
- }
-
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Disable color writes
- useSimpleShader();
- glEnable(GL_STENCIL_TEST); // For some reason, this has to happen _after_ the simple shader is use()'d
-
- if (mode == WindingFillMode) {
- Q_ASSERT(stops && !count);
- if (q->state()->clipTestEnabled) {
- // Flatten clip values higher than current clip, and set high bit to match current clip
- glStencilFunc(GL_LEQUAL, GL_STENCIL_HIGH_BIT | q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
- glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
- composite(bounds);
-
- glStencilFunc(GL_EQUAL, GL_STENCIL_HIGH_BIT, GL_STENCIL_HIGH_BIT);
- } else if (!stencilClean) {
- // Clear stencil buffer within bounding rect
- glStencilFunc(GL_ALWAYS, 0, 0xff);
- glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
- composite(bounds);
- }
-
- // Inc. for front-facing triangle
- glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_INCR_WRAP);
- // Dec. for back-facing "holes"
- glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_DECR_WRAP);
- glStencilMask(~GL_STENCIL_HIGH_BIT);
- drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);
-
- if (q->state()->clipTestEnabled) {
- // Clear high bit of stencil outside of path
- glStencilFunc(GL_EQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
- glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
- glStencilMask(GL_STENCIL_HIGH_BIT);
- composite(bounds);
- }
- } else if (mode == OddEvenFillMode) {
- glStencilMask(GL_STENCIL_HIGH_BIT);
- glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
- drawVertexArrays(data, stops, stopCount, GL_TRIANGLE_FAN);
-
- } else { // TriStripStrokeFillMode
- Q_ASSERT(count && !stops); // tristrips generated directly, so no vertexArray or stops
- glStencilMask(GL_STENCIL_HIGH_BIT);
-#if 0
- glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT); // Simply invert the stencil bit
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
- glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
-#else
-
- glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
- if (q->state()->clipTestEnabled) {
- glStencilFunc(GL_LEQUAL, q->state()->currentClip | GL_STENCIL_HIGH_BIT,
- ~GL_STENCIL_HIGH_BIT);
- } else {
- glStencilFunc(GL_ALWAYS, GL_STENCIL_HIGH_BIT, 0xff);
- }
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
- glDrawArrays(GL_TRIANGLE_STRIP, 0, count);
-#endif
- }
-
- // Enable color writes & disable stencil writes
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-}
-
-/*
- If the maximum value in the stencil buffer is GL_STENCIL_HIGH_BIT - 1,
- restore the stencil buffer to a pristine state. The current clip region
- is set to 1, and the rest to 0.
-*/
-void QGL2PaintEngineExPrivate::resetClipIfNeeded()
-{
- if (maxClip != (GL_STENCIL_HIGH_BIT - 1))
- return;
-
- Q_Q(QGL2PaintEngineEx);
-
- useSimpleShader();
- glEnable(GL_STENCIL_TEST);
- glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-
- QRectF bounds = q->state()->matrix.inverted().mapRect(QRectF(0, 0, width, height));
- QGLRect rect(bounds.left(), bounds.top(), bounds.right(), bounds.bottom());
-
- // Set high bit on clip region
- glStencilFunc(GL_LEQUAL, q->state()->currentClip, 0xff);
- glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
- glStencilMask(GL_STENCIL_HIGH_BIT);
- composite(rect);
-
- // Reset clipping to 1 and everything else to zero
- glStencilFunc(GL_NOTEQUAL, 0x01, GL_STENCIL_HIGH_BIT);
- glStencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
- glStencilMask(0xff);
- composite(rect);
-
- q->state()->currentClip = 1;
- q->state()->canRestoreClip = false;
-
- maxClip = 1;
-
- glStencilMask(0x0);
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-}
-
-bool QGL2PaintEngineExPrivate::prepareForCachedGlyphDraw(const QFontEngineGlyphCache &cache)
-{
- Q_Q(QGL2PaintEngineEx);
-
- Q_ASSERT(cache.transform().type() <= QTransform::TxScale);
-
- QTransform &transform = q->state()->matrix;
- transform.scale(1.0 / cache.transform().m11(), 1.0 / cache.transform().m22());
- bool ret = prepareForDraw(false);
- transform.scale(cache.transform().m11(), cache.transform().m22());
-
- return ret;
-}
-
-bool QGL2PaintEngineExPrivate::prepareForDraw(bool srcPixelsAreOpaque)
-{
- if (brushTextureDirty && mode != ImageDrawingMode && mode != ImageArrayDrawingMode)
- updateBrushTexture();
-
- if (compositionModeDirty)
- updateCompositionMode();
-
- if (matrixDirty)
- updateMatrix();
-
- const bool stateHasOpacity = q->state()->opacity < 0.99f;
- if (q->state()->composition_mode == QPainter::CompositionMode_Source
- || (q->state()->composition_mode == QPainter::CompositionMode_SourceOver
- && srcPixelsAreOpaque && !stateHasOpacity))
- {
- glDisable(GL_BLEND);
- } else {
- glEnable(GL_BLEND);
- }
-
- QGLEngineShaderManager::OpacityMode opacityMode;
- if (mode == ImageArrayDrawingMode) {
- opacityMode = QGLEngineShaderManager::AttributeOpacity;
- } else {
- opacityMode = stateHasOpacity ? QGLEngineShaderManager::UniformOpacity
- : QGLEngineShaderManager::NoOpacity;
- if (stateHasOpacity && (mode != ImageDrawingMode)) {
- // Using a brush
- bool brushIsPattern = (currentBrush.style() >= Qt::Dense1Pattern) &&
- (currentBrush.style() <= Qt::DiagCrossPattern);
-
- if ((currentBrush.style() == Qt::SolidPattern) || brushIsPattern)
- opacityMode = QGLEngineShaderManager::NoOpacity; // Global opacity handled by srcPixel shader
- }
- }
- shaderManager->setOpacityMode(opacityMode);
-
- bool changed = shaderManager->useCorrectShaderProg();
- // If the shader program needs changing, we change it and mark all uniforms as dirty
- if (changed) {
- // The shader program has changed so mark all uniforms as dirty:
- brushUniformsDirty = true;
- opacityUniformDirty = true;
- matrixUniformDirty = true;
- translateZUniformDirty = true;
- }
-
- if (brushUniformsDirty && mode != ImageDrawingMode && mode != ImageArrayDrawingMode)
- updateBrushUniforms();
-
- if (opacityMode == QGLEngineShaderManager::UniformOpacity && opacityUniformDirty) {
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::GlobalOpacity), (GLfloat)q->state()->opacity);
- opacityUniformDirty = false;
- }
-
- if (matrixUniformDirty && shaderManager->hasComplexGeometry()) {
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Matrix),
- pmvMatrix);
- matrixUniformDirty = false;
- }
-
- if (translateZUniformDirty && shaderManager->hasComplexGeometry()) {
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::TranslateZ),
- translateZ);
- translateZUniformDirty = false;
- }
-
- return changed;
-}
-
-void QGL2PaintEngineExPrivate::composite(const QGLRect& boundingRect)
-{
- setCoords(staticVertexCoordinateArray, boundingRect);
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, staticVertexCoordinateArray);
- glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-}
-
-// Draws the vertex array as a set of <vertexArrayStops.size()> triangle fans.
-void QGL2PaintEngineExPrivate::drawVertexArrays(const float *data, int *stops, int stopCount,
- GLenum primitive)
-{
- // Now setup the pointer to the vertex array:
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, data);
-
- int previousStop = 0;
- for (int i=0; i<stopCount; ++i) {
- int stop = stops[i];
-/*
- qDebug("Drawing triangle fan for vertecies %d -> %d:", previousStop, stop-1);
- for (int i=previousStop; i<stop; ++i)
- qDebug(" %02d: [%.2f, %.2f]", i, vertexArray.data()[i].x, vertexArray.data()[i].y);
-*/
- glDrawArrays(primitive, previousStop, stop - previousStop);
- previousStop = stop;
- }
-}
-
-/////////////////////////////////// Public Methods //////////////////////////////////////////
-
-QGL2PaintEngineEx::QGL2PaintEngineEx()
- : QPaintEngineEx(*(new QGL2PaintEngineExPrivate(this)))
-{
-}
-
-QGL2PaintEngineEx::~QGL2PaintEngineEx()
-{
-}
-
-void QGL2PaintEngineEx::fill(const QVectorPath &path, const QBrush &brush)
-{
- Q_D(QGL2PaintEngineEx);
-
- if (qbrush_style(brush) == Qt::NoBrush)
- return;
- ensureActive();
- d->setBrush(brush);
- d->fill(path);
-}
-
-Q_GUI_EXPORT bool qt_scaleForTransform(const QTransform &transform, qreal *scale); // qtransform.cpp
-
-
-void QGL2PaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
-{
- Q_D(QGL2PaintEngineEx);
-
- const QBrush &penBrush = qpen_brush(pen);
- if (qpen_style(pen) == Qt::NoPen || qbrush_style(penBrush) == Qt::NoBrush)
- return;
-
- QGL2PaintEngineState *s = state();
- if (qt_pen_is_cosmetic(pen, s->renderHints) && !qt_scaleForTransform(s->transform(), 0)) {
- // QTriangulatingStroker class is not meant to support cosmetically sheared strokes.
- QPaintEngineEx::stroke(path, pen);
- return;
- }
-
- ensureActive();
- d->setBrush(penBrush);
- d->stroke(path, pen);
-}
-
-void QGL2PaintEngineExPrivate::stroke(const QVectorPath &path, const QPen &pen)
-{
- const QGL2PaintEngineState *s = q->state();
- if (snapToPixelGrid) {
- snapToPixelGrid = false;
- matrixDirty = true;
- }
-
- const Qt::PenStyle penStyle = qpen_style(pen);
- const QBrush &penBrush = qpen_brush(pen);
- const bool opaque = penBrush.isOpaque() && s->opacity > 0.99;
-
- transferMode(BrushDrawingMode);
-
- // updateMatrix() is responsible for setting the inverse scale on
- // the strokers, so we need to call it here and not wait for
- // prepareForDraw() down below.
- updateMatrix();
-
- QRectF clip = q->state()->matrix.inverted().mapRect(q->state()->clipEnabled
- ? q->state()->rectangleClip
- : QRectF(0, 0, width, height));
-
- if (penStyle == Qt::SolidLine) {
- stroker.process(path, pen, clip, s->renderHints);
-
- } else { // Some sort of dash
- dasher.process(path, pen, clip, s->renderHints);
-
- QVectorPath dashStroke(dasher.points(),
- dasher.elementCount(),
- dasher.elementTypes());
- stroker.process(dashStroke, pen, clip, s->renderHints);
- }
-
- if (!stroker.vertexCount())
- return;
-
- if (opaque) {
- prepareForDraw(opaque);
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, stroker.vertices());
- glDrawArrays(GL_TRIANGLE_STRIP, 0, stroker.vertexCount() / 2);
-
-// QBrush b(Qt::green);
-// d->setBrush(&b);
-// d->prepareForDraw(true);
-// glDrawArrays(GL_LINE_STRIP, 0, d->stroker.vertexCount() / 2);
-
- } else {
- qreal width = qpen_widthf(pen) / 2;
- if (width == 0)
- width = 0.5;
- qreal extra = pen.joinStyle() == Qt::MiterJoin
- ? qMax(pen.miterLimit() * width, width)
- : width;
-
- if (qt_pen_is_cosmetic(pen, s->renderHints))
- extra = extra * inverseScale;
-
- QRectF bounds = path.controlPointRect().adjusted(-extra, -extra, extra, extra);
-
- fillStencilWithVertexArray(stroker.vertices(), stroker.vertexCount() / 2,
- 0, 0, bounds, QGL2PaintEngineExPrivate::TriStripStrokeFillMode);
-
- glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
-
- // Pass when any bit is set, replace stencil value with 0
- glStencilFunc(GL_NOTEQUAL, 0, GL_STENCIL_HIGH_BIT);
- prepareForDraw(false);
-
- // Stencil the brush onto the dest buffer
- composite(bounds);
-
- glStencilMask(0);
-
- updateClipScissorTest();
- }
-}
-
-void QGL2PaintEngineEx::penChanged() { }
-void QGL2PaintEngineEx::brushChanged() { }
-void QGL2PaintEngineEx::brushOriginChanged() { }
-
-void QGL2PaintEngineEx::opacityChanged()
-{
-// qDebug("QGL2PaintEngineEx::opacityChanged()");
- Q_D(QGL2PaintEngineEx);
- state()->opacityChanged = true;
-
- Q_ASSERT(d->shaderManager);
- d->brushUniformsDirty = true;
- d->opacityUniformDirty = true;
-}
-
-void QGL2PaintEngineEx::compositionModeChanged()
-{
-// qDebug("QGL2PaintEngineEx::compositionModeChanged()");
- Q_D(QGL2PaintEngineEx);
- state()->compositionModeChanged = true;
- d->compositionModeDirty = true;
-}
-
-void QGL2PaintEngineEx::renderHintsChanged()
-{
- Q_D(QGL2PaintEngineEx);
- state()->renderHintsChanged = true;
-
-#if !defined(QT_OPENGL_ES_2)
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
- if (!d->ctx->contextHandle()->isOpenGLES()) {
- if ((state()->renderHints & QPainter::Antialiasing)
-#if QT_DEPRECATED_SINCE(5, 14)
- || (state()->renderHints & QPainter::HighQualityAntialiasing)
-#endif
- )
- d->glEnable(GL_MULTISAMPLE);
- else
- d->glDisable(GL_MULTISAMPLE);
- }
-QT_WARNING_POP
-#endif
-
- d->lastTextureUsed = GLuint(-1);
- d->brushTextureDirty = true;
-// qDebug("QGL2PaintEngineEx::renderHintsChanged() not implemented!");
-}
-
-void QGL2PaintEngineEx::transformChanged()
-{
- Q_D(QGL2PaintEngineEx);
- d->matrixDirty = true;
- state()->matrixChanged = true;
-}
-
-
-static const QRectF scaleRect(const QRectF &r, qreal sx, qreal sy)
-{
- return QRectF(r.x() * sx, r.y() * sy, r.width() * sx, r.height() * sy);
-}
-
-void QGL2PaintEngineEx::drawPixmap(const QRectF& dest, const QPixmap & pixmap, const QRectF & src)
-{
- Q_D(QGL2PaintEngineEx);
- QGLContext *ctx = d->ctx;
-
- int max_texture_size = ctx->d_func()->maxTextureSize();
- if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
- QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
-
- const qreal sx = scaled.width() / qreal(pixmap.width());
- const qreal sy = scaled.height() / qreal(pixmap.height());
-
- drawPixmap(dest, scaled, scaleRect(src, sx, sy));
- return;
- }
-
- ensureActive();
- d->transferMode(ImageDrawingMode);
-
- QGLContext::BindOptions bindOptions = QGLContext::InternalBindOption|QGLContext::CanFlipNativePixmapBindOption;
-#ifdef QGL_USE_TEXTURE_POOL
- bindOptions |= QGLContext::TemporarilyCachedBindOption;
-#endif
-
- d->glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
- QGLTexture *texture =
- ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA, bindOptions);
-
- GLfloat top = texture->options & QGLContext::InvertedYBindOption ? (pixmap.height() - src.top()) : src.top();
- GLfloat bottom = texture->options & QGLContext::InvertedYBindOption ? (pixmap.height() - src.bottom()) : src.bottom();
- QGLRect srcRect(src.left(), top, src.right(), bottom);
-
- bool isBitmap = pixmap.isQBitmap();
- bool isOpaque = !isBitmap && !pixmap.hasAlpha();
-
- d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
- state()->renderHints & QPainter::SmoothPixmapTransform, texture->id);
- d->drawTexture(dest, srcRect, pixmap.size(), isOpaque, isBitmap);
-
- if (texture->options&QGLContext::TemporarilyCachedBindOption) {
- // pixmap was temporarily cached as a QImage texture by pooling system
- // and should be destroyed immediately
- QGLTextureCache::instance()->remove(ctx, texture->id);
- }
-}
-
-void QGL2PaintEngineEx::drawImage(const QRectF& dest, const QImage& image, const QRectF& src,
- Qt::ImageConversionFlags)
-{
- Q_D(QGL2PaintEngineEx);
- QGLContext *ctx = d->ctx;
-
- int max_texture_size = ctx->d_func()->maxTextureSize();
- if (image.width() > max_texture_size || image.height() > max_texture_size) {
- QImage scaled = image.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
-
- const qreal sx = scaled.width() / qreal(image.width());
- const qreal sy = scaled.height() / qreal(image.height());
-
- drawImage(dest, scaled, scaleRect(src, sx, sy));
- return;
- }
-
- ensureActive();
- d->transferMode(ImageDrawingMode);
-
- d->glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
-
- QGLContext::BindOptions bindOptions = QGLContext::InternalBindOption;
-#ifdef QGL_USE_TEXTURE_POOL
- bindOptions |= QGLContext::TemporarilyCachedBindOption;
-#endif
-
- QGLTexture *texture = ctx->d_func()->bindTexture(image, GL_TEXTURE_2D, GL_RGBA, bindOptions);
- GLuint id = texture->id;
-
- d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
- state()->renderHints & QPainter::SmoothPixmapTransform, id);
- d->drawTexture(dest, src, image.size(), !image.hasAlphaChannel());
-
- if (texture->options&QGLContext::TemporarilyCachedBindOption) {
- // image was temporarily cached by texture pooling system
- // and should be destroyed immediately
- QGLTextureCache::instance()->remove(ctx, texture->id);
- }
-}
-
-void QGL2PaintEngineEx::drawStaticTextItem(QStaticTextItem *textItem)
-{
- Q_D(QGL2PaintEngineEx);
-
- ensureActive();
-
- QPainterState *s = state();
-
- // don't try to cache huge fonts or vastly transformed fonts
- QFontEngine *fontEngine = textItem->fontEngine();
- if (shouldDrawCachedGlyphs(fontEngine, s->matrix)) {
-
- QFontEngine::GlyphFormat glyphFormat = fontEngine->glyphFormat != QFontEngine::Format_None
- ? fontEngine->glyphFormat : d->glyphCacheFormat;
-
- if (glyphFormat == QFontEngine::Format_A32) {
- if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()
- || d->device->alphaRequested() || s->matrix.type() > QTransform::TxTranslate
- || (s->composition_mode != QPainter::CompositionMode_Source
- && s->composition_mode != QPainter::CompositionMode_SourceOver))
- {
- glyphFormat = QFontEngine::Format_A8;
- }
- }
-
- d->drawCachedGlyphs(glyphFormat, textItem);
- } else {
- QPaintEngineEx::drawStaticTextItem(textItem);
- }
-}
-
-bool QGL2PaintEngineEx::drawTexture(const QRectF &dest, GLuint textureId, const QSize &size, const QRectF &src)
-{
- Q_D(QGL2PaintEngineEx);
- if (!d->shaderManager)
- return false;
-
- ensureActive();
- d->transferMode(ImageDrawingMode);
-
- d->glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
- d->glBindTexture(GL_TEXTURE_2D, textureId);
-
- QGLRect srcRect(src.left(), src.bottom(), src.right(), src.top());
-
- d->updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
- state()->renderHints & QPainter::SmoothPixmapTransform, textureId);
- d->drawTexture(dest, srcRect, size, false);
- return true;
-}
-
-void QGL2PaintEngineEx::drawTextItem(const QPointF &p, const QTextItem &textItem)
-{
- Q_D(QGL2PaintEngineEx);
-
- ensureActive();
- QGL2PaintEngineState *s = state();
-
- const QTextItemInt &ti = static_cast<const QTextItemInt &>(textItem);
-
- QTransform::TransformationType txtype = s->matrix.type();
-
- QFontEngine::GlyphFormat glyphFormat = ti.fontEngine->glyphFormat != QFontEngine::Format_None
- ? ti.fontEngine->glyphFormat : d->glyphCacheFormat;
-
- if (glyphFormat == QFontEngine::Format_A32) {
- if (!QGLFramebufferObject::hasOpenGLFramebufferObjects()
- || d->device->alphaRequested() || txtype > QTransform::TxTranslate
- || (state()->composition_mode != QPainter::CompositionMode_Source
- && state()->composition_mode != QPainter::CompositionMode_SourceOver))
- {
- glyphFormat = QFontEngine::Format_A8;
- }
- }
-
- if (shouldDrawCachedGlyphs(ti.fontEngine, s->matrix)) {
- QVarLengthArray<QFixedPoint> positions;
- QVarLengthArray<glyph_t> glyphs;
- QTransform matrix = QTransform::fromTranslate(p.x(), p.y());
- ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
-
- {
- QStaticTextItem staticTextItem;
- staticTextItem.setFontEngine(ti.fontEngine);
- staticTextItem.glyphs = glyphs.data();
- staticTextItem.numGlyphs = glyphs.size();
- staticTextItem.glyphPositions = positions.data();
-
- d->drawCachedGlyphs(glyphFormat, &staticTextItem);
- }
- return;
- }
-
- QPaintEngineEx::drawTextItem(p, ti);
-}
-
-namespace {
-
- class QOpenGLStaticTextUserData: public QStaticTextUserData
- {
- public:
- QOpenGLStaticTextUserData()
- : QStaticTextUserData(OpenGLUserData), cacheSize(0, 0), cacheSerialNumber(0)
- {
- }
-
- ~QOpenGLStaticTextUserData()
- {
- }
-
- QSize cacheSize;
- QGL2PEXVertexArray vertexCoordinateArray;
- QGL2PEXVertexArray textureCoordinateArray;
- QFontEngine::GlyphFormat glyphFormat;
- int cacheSerialNumber;
- };
-
-}
-
-
-// #define QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO
-
-void QGL2PaintEngineExPrivate::drawCachedGlyphs(QFontEngine::GlyphFormat glyphFormat,
- QStaticTextItem *staticTextItem)
-{
- Q_Q(QGL2PaintEngineEx);
-
- QGL2PaintEngineState *s = q->state();
-
- void *cacheKey = const_cast<QGLContext *>(QGLContextPrivate::contextGroup(ctx)->context());
- bool recreateVertexArrays = false;
-
- QTransform glyphCacheTransform;
- QFontEngine *fe = staticTextItem->fontEngine();
- if (fe->supportsTransformation(s->matrix)) {
- // The font-engine supports rendering glyphs with the current transform, so we
- // build a glyph-cache with the scale pre-applied, so that the cache contains
- // glyphs with the appropriate resolution in the case of retina displays.
- glyphCacheTransform = s->matrix.type() < QTransform::TxRotate ?
- QTransform::fromScale(qAbs(s->matrix.m11()), qAbs(s->matrix.m22())) :
- QTransform::fromScale(
- QVector2D(s->matrix.m11(), s->matrix.m12()).length(),
- QVector2D(s->matrix.m21(), s->matrix.m22()).length());
- }
-
- QGLTextureGlyphCache *cache =
- (QGLTextureGlyphCache *) fe->glyphCache(cacheKey, glyphFormat, glyphCacheTransform);
- if (!cache || cache->glyphFormat() != glyphFormat || cache->contextGroup() == 0) {
- cache = new QGLTextureGlyphCache(glyphFormat, glyphCacheTransform);
- fe->setGlyphCache(cacheKey, cache);
- recreateVertexArrays = true;
- }
-
- if (staticTextItem->userDataNeedsUpdate) {
- recreateVertexArrays = true;
- } else if (staticTextItem->userData() == 0) {
- recreateVertexArrays = true;
- } else if (staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
- recreateVertexArrays = true;
- } else {
- QOpenGLStaticTextUserData *userData = static_cast<QOpenGLStaticTextUserData *>(staticTextItem->userData());
- if (userData->glyphFormat != glyphFormat) {
- recreateVertexArrays = true;
- } else if (userData->cacheSerialNumber != cache->serialNumber()) {
- recreateVertexArrays = true;
- }
- }
-
- // We only need to update the cache with new glyphs if we are actually going to recreate the vertex arrays.
- // If the cache size has changed, we do need to regenerate the vertices, but we don't need to repopulate the
- // cache so this text is performed before we test if the cache size has changed.
- if (recreateVertexArrays) {
- cache->setPaintEnginePrivate(this);
- if (!cache->populate(fe, staticTextItem->numGlyphs,
- staticTextItem->glyphs, staticTextItem->glyphPositions)) {
- // No space for glyphs in cache. We need to reset it and try again.
- cache->clear();
- cache->populate(fe, staticTextItem->numGlyphs,
- staticTextItem->glyphs, staticTextItem->glyphPositions);
- }
- cache->fillInPendingGlyphs();
- }
-
- if (cache->width() == 0 || cache->height() == 0)
- return;
-
- transferMode(TextDrawingMode);
-
- int margin = fe->glyphMargin(glyphFormat);
-
- GLfloat dx = 1.0 / cache->width();
- GLfloat dy = 1.0 / cache->height();
-
- // Use global arrays by default
- QGL2PEXVertexArray *vertexCoordinates = &vertexCoordinateArray;
- QGL2PEXVertexArray *textureCoordinates = &textureCoordinateArray;
-
- if (staticTextItem->useBackendOptimizations) {
- QOpenGLStaticTextUserData *userData = 0;
-
- if (staticTextItem->userData() == 0
- || staticTextItem->userData()->type != QStaticTextUserData::OpenGLUserData) {
-
- userData = new QOpenGLStaticTextUserData();
- staticTextItem->setUserData(userData);
-
- } else {
- userData = static_cast<QOpenGLStaticTextUserData*>(staticTextItem->userData());
- }
-
- userData->glyphFormat = glyphFormat;
- userData->cacheSerialNumber = cache->serialNumber();
-
- // Use cache if backend optimizations is turned on
- vertexCoordinates = &userData->vertexCoordinateArray;
- textureCoordinates = &userData->textureCoordinateArray;
-
- QSize size(cache->width(), cache->height());
- if (userData->cacheSize != size) {
- recreateVertexArrays = true;
- userData->cacheSize = size;
- }
- }
-
- if (recreateVertexArrays) {
- vertexCoordinates->clear();
- textureCoordinates->clear();
-
- bool supportsSubPixelPositions = fe->supportsSubPixelPositions();
- for (int i=0; i<staticTextItem->numGlyphs; ++i) {
- QFixed subPixelPosition;
- if (supportsSubPixelPositions)
- subPixelPosition = fe->subPixelPositionForX(staticTextItem->glyphPositions[i].x);
-
- QTextureGlyphCache::GlyphAndSubPixelPosition glyph(staticTextItem->glyphs[i], subPixelPosition);
-
- const QTextureGlyphCache::Coord &c = cache->coords[glyph];
- if (c.isNull())
- continue;
-
- int x = qFloor(staticTextItem->glyphPositions[i].x.toReal() * cache->transform().m11()) + c.baseLineX - margin;
- int y = qRound(staticTextItem->glyphPositions[i].y.toReal() * cache->transform().m22()) - c.baseLineY - margin;
-
- vertexCoordinates->addQuad(QRectF(x, y, c.w, c.h));
- textureCoordinates->addQuad(QRectF(c.x*dx, c.y*dy, c.w * dx, c.h * dy));
- }
-
- staticTextItem->userDataNeedsUpdate = false;
- }
-
- int numGlyphs = vertexCoordinates->vertexCount() / 4;
- if (numGlyphs == 0)
- return;
-
- if (elementIndices.size() < numGlyphs*6) {
- Q_ASSERT(elementIndices.size() % 6 == 0);
- int j = elementIndices.size() / 6 * 4;
- while (j < numGlyphs*4) {
- elementIndices.append(j + 0);
- elementIndices.append(j + 0);
- elementIndices.append(j + 1);
- elementIndices.append(j + 2);
- elementIndices.append(j + 3);
- elementIndices.append(j + 3);
-
- j += 4;
- }
-
-#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
- if (elementIndicesVBOId == 0)
- glGenBuffers(1, &elementIndicesVBOId);
-
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementIndices.size() * sizeof(GLushort),
- elementIndices.constData(), GL_STATIC_DRAW);
-#endif
- } else {
-#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementIndicesVBOId);
-#endif
- }
-
- setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, (GLfloat*)vertexCoordinates->data());
- setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, (GLfloat*)textureCoordinates->data());
-
- if (!snapToPixelGrid) {
- snapToPixelGrid = true;
- matrixDirty = true;
- }
-
- QBrush pensBrush = q->state()->pen.brush();
- setBrush(pensBrush);
-
- if (glyphFormat == QFontEngine::Format_A32) {
-
- // Subpixel antialiasing without gamma correction
-
- QPainter::CompositionMode compMode = q->state()->composition_mode;
- Q_ASSERT(compMode == QPainter::CompositionMode_Source
- || compMode == QPainter::CompositionMode_SourceOver);
-
- shaderManager->setMaskType(QGLEngineShaderManager::SubPixelMaskPass1);
-
- if (pensBrush.style() == Qt::SolidPattern) {
- // Solid patterns can get away with only one pass.
- QColor c = pensBrush.color();
- qreal oldOpacity = q->state()->opacity;
- if (compMode == QPainter::CompositionMode_Source) {
- c = qt_premultiplyColor(c, q->state()->opacity);
- q->state()->opacity = 1;
- opacityUniformDirty = true;
- }
-
- compositionModeDirty = false; // I can handle this myself, thank you very much
- prepareForCachedGlyphDraw(*cache);
-
- // prepareForCachedGlyphDraw() have set the opacity on the current shader, so the opacity state can now be reset.
- if (compMode == QPainter::CompositionMode_Source) {
- q->state()->opacity = oldOpacity;
- opacityUniformDirty = true;
- }
-
- glEnable(GL_BLEND);
- glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_SRC_COLOR);
- glBlendColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
- } else {
- // Other brush styles need two passes.
-
- qreal oldOpacity = q->state()->opacity;
- if (compMode == QPainter::CompositionMode_Source) {
- q->state()->opacity = 1;
- opacityUniformDirty = true;
- pensBrush = Qt::white;
- setBrush(pensBrush);
- }
-
- compositionModeDirty = false; // I can handle this myself, thank you very much
- prepareForCachedGlyphDraw(*cache);
- glEnable(GL_BLEND);
- glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
-
- glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
- glBindTexture(GL_TEXTURE_2D, cache->texture());
- updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, false);
-
-#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
- glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
-#else
- glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
-#endif
-
- shaderManager->setMaskType(QGLEngineShaderManager::SubPixelMaskPass2);
-
- if (compMode == QPainter::CompositionMode_Source) {
- q->state()->opacity = oldOpacity;
- opacityUniformDirty = true;
- pensBrush = q->state()->pen.brush();
- setBrush(pensBrush);
- }
-
- compositionModeDirty = false;
- prepareForCachedGlyphDraw(*cache);
- glEnable(GL_BLEND);
- glBlendFunc(GL_ONE, GL_ONE);
- }
- compositionModeDirty = true;
- } else {
- // Grayscale/mono glyphs
-
- shaderManager->setMaskType(QGLEngineShaderManager::PixelMask);
- prepareForCachedGlyphDraw(*cache);
- }
-
- QGLTextureGlyphCache::FilterMode filterMode = (s->matrix.type() > QTransform::TxTranslate)?QGLTextureGlyphCache::Linear:QGLTextureGlyphCache::Nearest;
- if (lastMaskTextureUsed != cache->texture() || cache->filterMode() != filterMode) {
-
- glActiveTexture(GL_TEXTURE0 + QT_MASK_TEXTURE_UNIT);
- if (lastMaskTextureUsed != cache->texture()) {
- glBindTexture(GL_TEXTURE_2D, cache->texture());
- lastMaskTextureUsed = cache->texture();
- }
-
- if (cache->filterMode() != filterMode) {
- if (filterMode == QGLTextureGlyphCache::Linear) {
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- } else {
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- }
- cache->setFilterMode(filterMode);
- }
- }
-
-#if defined(QT_OPENGL_DRAWCACHEDGLYPHS_INDEX_ARRAY_VBO)
- glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-#else
- glDrawElements(GL_TRIANGLE_STRIP, 6 * numGlyphs, GL_UNSIGNED_SHORT, elementIndices.data());
-#endif
-}
-
-void QGL2PaintEngineEx::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
- QPainter::PixmapFragmentHints hints)
-{
- Q_D(QGL2PaintEngineEx);
- // Use fallback for extended composition modes.
- if (state()->composition_mode > QPainter::CompositionMode_Plus) {
- QPaintEngineEx::drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
- return;
- }
-
- ensureActive();
- int max_texture_size = d->ctx->d_func()->maxTextureSize();
- if (pixmap.width() > max_texture_size || pixmap.height() > max_texture_size) {
- QPixmap scaled = pixmap.scaled(max_texture_size, max_texture_size, Qt::KeepAspectRatio);
- d->drawPixmapFragments(fragments, fragmentCount, scaled, hints);
- } else {
- d->drawPixmapFragments(fragments, fragmentCount, pixmap, hints);
- }
-}
-
-
-void QGL2PaintEngineExPrivate::drawPixmapFragments(const QPainter::PixmapFragment *fragments,
- int fragmentCount, const QPixmap &pixmap,
- QPainter::PixmapFragmentHints hints)
-{
- GLfloat dx = 1.0f / pixmap.size().width();
- GLfloat dy = 1.0f / pixmap.size().height();
-
- vertexCoordinateArray.clear();
- textureCoordinateArray.clear();
- opacityArray.reset();
-
- if (snapToPixelGrid) {
- snapToPixelGrid = false;
- matrixDirty = true;
- }
-
- bool allOpaque = true;
-
- for (int i = 0; i < fragmentCount; ++i) {
- qreal s = 0;
- qreal c = 1;
- if (fragments[i].rotation != 0) {
- s = qFastSin(qDegreesToRadians(fragments[i].rotation));
- c = qFastCos(qDegreesToRadians(fragments[i].rotation));
- }
-
- qreal right = 0.5 * fragments[i].scaleX * fragments[i].width;
- qreal bottom = 0.5 * fragments[i].scaleY * fragments[i].height;
- QGLPoint bottomRight(right * c - bottom * s, right * s + bottom * c);
- QGLPoint bottomLeft(-right * c - bottom * s, -right * s + bottom * c);
-
- vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
- vertexCoordinateArray.addVertex(-bottomLeft.x + fragments[i].x, -bottomLeft.y + fragments[i].y);
- vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
- vertexCoordinateArray.addVertex(-bottomRight.x + fragments[i].x, -bottomRight.y + fragments[i].y);
- vertexCoordinateArray.addVertex(bottomLeft.x + fragments[i].x, bottomLeft.y + fragments[i].y);
- vertexCoordinateArray.addVertex(bottomRight.x + fragments[i].x, bottomRight.y + fragments[i].y);
-
- QGLRect src(fragments[i].sourceLeft * dx, fragments[i].sourceTop * dy,
- (fragments[i].sourceLeft + fragments[i].width) * dx,
- (fragments[i].sourceTop + fragments[i].height) * dy);
-
- textureCoordinateArray.addVertex(src.right, src.bottom);
- textureCoordinateArray.addVertex(src.right, src.top);
- textureCoordinateArray.addVertex(src.left, src.top);
- textureCoordinateArray.addVertex(src.left, src.top);
- textureCoordinateArray.addVertex(src.left, src.bottom);
- textureCoordinateArray.addVertex(src.right, src.bottom);
-
- qreal opacity = fragments[i].opacity * q->state()->opacity;
- opacityArray << opacity << opacity << opacity << opacity << opacity << opacity;
- allOpaque &= (opacity >= 0.99f);
- }
-
- glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
- QGLTexture *texture = ctx->d_func()->bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA,
- QGLContext::InternalBindOption
- | QGLContext::CanFlipNativePixmapBindOption);
-
- if (texture->options & QGLContext::InvertedYBindOption) {
- // Flip texture y-coordinate.
- QGLPoint *data = textureCoordinateArray.data();
- for (int i = 0; i < 6 * fragmentCount; ++i)
- data[i].y = 1 - data[i].y;
- }
-
- transferMode(ImageArrayDrawingMode);
-
- bool isBitmap = pixmap.isQBitmap();
- bool isOpaque = !isBitmap && (!pixmap.hasAlpha() || (hints & QPainter::OpaqueHint)) && allOpaque;
-
- updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
- q->state()->renderHints & QPainter::SmoothPixmapTransform, texture->id);
-
- // Setup for texture drawing
- currentBrush = noBrush;
- shaderManager->setSrcPixelType(isBitmap ? QGLEngineShaderManager::PatternSrc
- : QGLEngineShaderManager::ImageSrc);
- if (prepareForDraw(isOpaque))
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);
-
- if (isBitmap) {
- QColor col = qt_premultiplyColor(q->state()->pen.color(), (GLfloat)q->state()->opacity);
- shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);
- }
-
- glDrawArrays(GL_TRIANGLES, 0, 6 * fragmentCount);
-}
-
-bool QGL2PaintEngineEx::begin(QPaintDevice *pdev)
-{
- Q_D(QGL2PaintEngineEx);
-
-// qDebug("QGL2PaintEngineEx::begin()");
- if (pdev->devType() == QInternal::OpenGL)
- d->device = static_cast<QGLPaintDevice*>(pdev);
- else
- d->device = QGLPaintDevice::getDevice(pdev);
-
- if (!d->device)
- return false;
-
- d->ctx = d->device->context();
- d->ctx->d_ptr->active_engine = this;
-
- d->resetOpenGLContextActiveEngine();
-
- const QSize sz = d->device->size();
- d->width = sz.width();
- d->height = sz.height();
- d->mode = BrushDrawingMode;
- d->brushTextureDirty = true;
- d->brushUniformsDirty = true;
- d->matrixUniformDirty = true;
- d->matrixDirty = true;
- d->compositionModeDirty = true;
- d->opacityUniformDirty = true;
- d->translateZUniformDirty = true;
- d->needsSync = true;
- d->useSystemClip = !systemClip().isEmpty();
- d->currentBrush = QBrush();
-
- d->dirtyStencilRegion = QRect(0, 0, d->width, d->height);
- d->stencilClean = true;
-
- // Calling begin paint should make the correct context current. So, any
- // code which calls into GL or otherwise needs a current context *must*
- // go after beginPaint:
- d->device->beginPaint();
-
- d->initializeOpenGLFunctions();
-
- d->shaderManager = new QGLEngineShaderManager(d->ctx);
-
- d->glDisable(GL_STENCIL_TEST);
- d->glDisable(GL_DEPTH_TEST);
- d->glDisable(GL_SCISSOR_TEST);
-
-#if !defined(QT_OPENGL_ES_2)
- if (!d->ctx->contextHandle()->isOpenGLES())
- d->glDisable(GL_MULTISAMPLE);
-#endif
-
- d->glyphCacheFormat = QFontEngine::Format_A8;
-
-#if !defined(QT_OPENGL_ES_2)
- if (!d->ctx->contextHandle()->isOpenGLES()) {
- d->glyphCacheFormat = QFontEngine::Format_A32;
- d->multisamplingAlwaysEnabled = false;
- } else {
- d->multisamplingAlwaysEnabled = d->device->format().sampleBuffers();
- }
-#else
- // OpenGL ES can't switch MSAA off, so if the gl paint device is
- // multisampled, it's always multisampled.
- d->multisamplingAlwaysEnabled = d->device->format().sampleBuffers();
-#endif
-
- return true;
-}
-
-bool QGL2PaintEngineEx::end()
-{
- Q_D(QGL2PaintEngineEx);
-
- QGLContext *ctx = d->ctx;
- d->glUseProgram(0);
- d->transferMode(BrushDrawingMode);
- d->device->endPaint();
-
- ctx->d_ptr->active_engine = 0;
- ctx->makeCurrent();
- d->resetOpenGLContextActiveEngine();
- d->resetGLState();
-
- delete d->shaderManager;
- d->shaderManager = 0;
- d->currentBrush = QBrush();
-
-#ifdef QT_OPENGL_CACHE_AS_VBOS
- if (!d->unusedVBOSToClean.isEmpty()) {
- d->glDeleteBuffers(d->unusedVBOSToClean.size(), d->unusedVBOSToClean.constData());
- d->unusedVBOSToClean.clear();
- }
- if (!d->unusedIBOSToClean.isEmpty()) {
- d->glDeleteBuffers(d->unusedIBOSToClean.size(), d->unusedIBOSToClean.constData());
- d->unusedIBOSToClean.clear();
- }
-#endif
-
- return false;
-}
-
-void QGL2PaintEngineEx::ensureActive()
-{
- Q_D(QGL2PaintEngineEx);
- QGLContext *ctx = d->ctx;
-
- if (isActive() && (ctx->d_ptr->active_engine != this || d->resetOpenGLContextActiveEngine())) {
- ctx->d_ptr->active_engine = this;
- d->needsSync = true;
- }
-
- d->device->ensureActiveTarget();
-
- if (d->needsSync) {
- d->transferMode(BrushDrawingMode);
- d->glViewport(0, 0, d->width, d->height);
- d->needsSync = false;
- d->lastMaskTextureUsed = 0;
- d->shaderManager->setDirty();
- d->ctx->d_func()->syncGlState();
- for (int i = 0; i < 3; ++i)
- d->vertexAttribPointers[i] = (GLfloat*)-1; // Assume the pointers are clobbered
- setState(state());
- }
-}
-
-void QGL2PaintEngineExPrivate::updateClipScissorTest()
-{
- Q_Q(QGL2PaintEngineEx);
- if (q->state()->clipTestEnabled) {
- glEnable(GL_STENCIL_TEST);
- glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
- } else {
- glDisable(GL_STENCIL_TEST);
- glStencilFunc(GL_ALWAYS, 0, 0xff);
- }
-
-#ifdef QT_GL_NO_SCISSOR_TEST
- currentScissorBounds = QRect(0, 0, width, height);
-#else
- QRect bounds = q->state()->rectangleClip;
- if (!q->state()->clipEnabled) {
- if (useSystemClip)
- bounds = systemClip.boundingRect();
- else
- bounds = QRect(0, 0, width, height);
- } else {
- if (useSystemClip)
- bounds = bounds.intersected(systemClip.boundingRect());
- else
- bounds = bounds.intersected(QRect(0, 0, width, height));
- }
-
- currentScissorBounds = bounds;
-
- if (bounds == QRect(0, 0, width, height)) {
- glDisable(GL_SCISSOR_TEST);
- } else {
- glEnable(GL_SCISSOR_TEST);
- setScissor(bounds);
- }
-#endif
-}
-
-void QGL2PaintEngineExPrivate::setScissor(const QRect &rect)
-{
- const int left = rect.left();
- const int width = rect.width();
- int bottom = height - (rect.top() + rect.height());
- if (device->isFlipped()) {
- bottom = rect.top();
- }
- const int height = rect.height();
-
- glScissor(left, bottom, width, height);
-}
-
-void QGL2PaintEngineEx::clipEnabledChanged()
-{
- Q_D(QGL2PaintEngineEx);
-
- state()->clipChanged = true;
-
- if (painter()->hasClipping())
- d->regenerateClip();
- else
- d->systemStateChanged();
-}
-
-void QGL2PaintEngineExPrivate::clearClip(uint value)
-{
- dirtyStencilRegion -= currentScissorBounds;
-
- glStencilMask(0xff);
- glClearStencil(value);
- glClear(GL_STENCIL_BUFFER_BIT);
- glStencilMask(0x0);
-
- q->state()->needsClipBufferClear = false;
-}
-
-void QGL2PaintEngineExPrivate::writeClip(const QVectorPath &path, uint value)
-{
- transferMode(BrushDrawingMode);
-
- if (snapToPixelGrid) {
- snapToPixelGrid = false;
- matrixDirty = true;
- }
-
- if (matrixDirty)
- updateMatrix();
-
- stencilClean = false;
-
- const bool singlePass = !path.hasWindingFill()
- && (((q->state()->currentClip == maxClip - 1) && q->state()->clipTestEnabled)
- || q->state()->needsClipBufferClear);
- const uint referenceClipValue = q->state()->needsClipBufferClear ? 1 : q->state()->currentClip;
-
- if (q->state()->needsClipBufferClear)
- clearClip(1);
-
- if (path.isEmpty()) {
- glEnable(GL_STENCIL_TEST);
- glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
- return;
- }
-
- if (q->state()->clipTestEnabled)
- glStencilFunc(GL_LEQUAL, q->state()->currentClip, ~GL_STENCIL_HIGH_BIT);
- else
- glStencilFunc(GL_ALWAYS, 0, 0xff);
-
- vertexCoordinateArray.clear();
- vertexCoordinateArray.addPath(path, inverseScale, false);
-
- if (!singlePass)
- fillStencilWithVertexArray(vertexCoordinateArray, path.hasWindingFill());
-
- glColorMask(false, false, false, false);
- glEnable(GL_STENCIL_TEST);
- useSimpleShader();
-
- if (singlePass) {
- // Under these conditions we can set the new stencil value in a single
- // pass, by using the current value and the "new value" as the toggles
-
- glStencilFunc(GL_LEQUAL, referenceClipValue, ~GL_STENCIL_HIGH_BIT);
- glStencilOp(GL_KEEP, GL_INVERT, GL_INVERT);
- glStencilMask(value ^ referenceClipValue);
-
- drawVertexArrays(vertexCoordinateArray, GL_TRIANGLE_FAN);
- } else {
- glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
- glStencilMask(0xff);
-
- if (!q->state()->clipTestEnabled && path.hasWindingFill()) {
- // Pass when any clip bit is set, set high bit
- glStencilFunc(GL_NOTEQUAL, GL_STENCIL_HIGH_BIT, ~GL_STENCIL_HIGH_BIT);
- composite(vertexCoordinateArray.boundingRect());
- }
-
- // Pass when high bit is set, replace stencil value with new clip value
- glStencilFunc(GL_NOTEQUAL, value, GL_STENCIL_HIGH_BIT);
-
- composite(vertexCoordinateArray.boundingRect());
- }
-
- glStencilFunc(GL_LEQUAL, value, ~GL_STENCIL_HIGH_BIT);
- glStencilMask(0);
-
- glColorMask(true, true, true, true);
-}
-
-void QGL2PaintEngineEx::clip(const QVectorPath &path, Qt::ClipOperation op)
-{
-// qDebug("QGL2PaintEngineEx::clip()");
- Q_D(QGL2PaintEngineEx);
-
- state()->clipChanged = true;
-
- ensureActive();
-
- if (op == Qt::ReplaceClip) {
- op = Qt::IntersectClip;
- if (d->hasClipOperations()) {
- d->systemStateChanged();
- state()->canRestoreClip = false;
- }
- }
-
-#ifndef QT_GL_NO_SCISSOR_TEST
- if (!path.isEmpty() && op == Qt::IntersectClip && (path.shape() == QVectorPath::RectangleHint)) {
- const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
- QRectF rect(points[0], points[2]);
-
- if (state()->matrix.type() <= QTransform::TxScale
- || (state()->matrix.type() == QTransform::TxRotate
- && qFuzzyIsNull(state()->matrix.m11())
- && qFuzzyIsNull(state()->matrix.m22())))
- {
- state()->rectangleClip = state()->rectangleClip.intersected(state()->matrix.mapRect(rect).toRect());
- d->updateClipScissorTest();
- return;
- }
- }
-#endif
-
- const QRect pathRect = state()->matrix.mapRect(path.controlPointRect()).toAlignedRect();
-
- switch (op) {
- case Qt::NoClip:
- if (d->useSystemClip) {
- state()->clipTestEnabled = true;
- state()->currentClip = 1;
- } else {
- state()->clipTestEnabled = false;
- }
- state()->rectangleClip = QRect(0, 0, d->width, d->height);
- state()->canRestoreClip = false;
- d->updateClipScissorTest();
- break;
- case Qt::IntersectClip:
- state()->rectangleClip = state()->rectangleClip.intersected(pathRect);
- d->updateClipScissorTest();
- d->resetClipIfNeeded();
- ++d->maxClip;
- d->writeClip(path, d->maxClip);
- state()->currentClip = d->maxClip;
- state()->clipTestEnabled = true;
- break;
- default:
- break;
- }
-}
-
-void QGL2PaintEngineExPrivate::regenerateClip()
-{
- systemStateChanged();
- replayClipOperations();
-}
-
-void QGL2PaintEngineExPrivate::systemStateChanged()
-{
- Q_Q(QGL2PaintEngineEx);
-
- q->state()->clipChanged = true;
-
- if (systemClip.isEmpty()) {
- useSystemClip = false;
- } else {
- if (q->paintDevice()->devType() == QInternal::Widget && currentClipDevice) {
- QWidgetPrivate *widgetPrivate = qt_widget_private(static_cast<QWidget *>(currentClipDevice)->window());
- useSystemClip = widgetPrivate->extra && widgetPrivate->extra->inRenderWithPainter;
- } else {
- useSystemClip = true;
- }
- }
-
- q->state()->clipTestEnabled = false;
- q->state()->needsClipBufferClear = true;
-
- q->state()->currentClip = 1;
- maxClip = 1;
-
- q->state()->rectangleClip = useSystemClip ? systemClip.boundingRect() : QRect(0, 0, width, height);
- updateClipScissorTest();
-
- if (systemClip.rectCount() == 1) {
- if (systemClip.boundingRect() == QRect(0, 0, width, height))
- useSystemClip = false;
-#ifndef QT_GL_NO_SCISSOR_TEST
- // scissoring takes care of the system clip
- return;
-#endif
- }
-
- if (useSystemClip) {
- clearClip(0);
-
- QPainterPath path;
- path.addRegion(systemClip);
-
- q->state()->currentClip = 0;
- writeClip(qtVectorPathForPath(q->state()->matrix.inverted().map(path)), 1);
- q->state()->currentClip = 1;
- q->state()->clipTestEnabled = true;
- }
-}
-
-void QGL2PaintEngineEx::setTranslateZ(GLfloat z)
-{
- Q_D(QGL2PaintEngineEx);
- if (d->translateZ != z) {
- d->translateZ = z;
- d->translateZUniformDirty = true;
- }
-}
-
-void QGL2PaintEngineEx::setState(QPainterState *new_state)
-{
- // qDebug("QGL2PaintEngineEx::setState()");
-
- Q_D(QGL2PaintEngineEx);
-
- QGL2PaintEngineState *s = static_cast<QGL2PaintEngineState *>(new_state);
- QGL2PaintEngineState *old_state = state();
-
- QPaintEngineEx::setState(s);
-
- if (s->isNew) {
- // Newly created state object. The call to setState()
- // will either be followed by a call to begin(), or we are
- // setting the state as part of a save().
- s->isNew = false;
- return;
- }
-
- // Setting the state as part of a restore().
-
- if (old_state == s || old_state->renderHintsChanged)
- renderHintsChanged();
-
- if (old_state == s || old_state->matrixChanged)
- d->matrixDirty = true;
-
- if (old_state == s || old_state->compositionModeChanged)
- d->compositionModeDirty = true;
-
- if (old_state == s || old_state->opacityChanged)
- d->opacityUniformDirty = true;
-
- if (old_state == s || old_state->clipChanged) {
- if (old_state && old_state != s && old_state->canRestoreClip) {
- d->updateClipScissorTest();
- d->glDepthFunc(GL_LEQUAL);
- } else {
- d->regenerateClip();
- }
- }
-}
-
-QPainterState *QGL2PaintEngineEx::createState(QPainterState *orig) const
-{
- if (orig)
- const_cast<QGL2PaintEngineEx *>(this)->ensureActive();
-
- QGL2PaintEngineState *s;
- if (!orig)
- s = new QGL2PaintEngineState();
- else
- s = new QGL2PaintEngineState(*static_cast<QGL2PaintEngineState *>(orig));
-
- s->matrixChanged = false;
- s->compositionModeChanged = false;
- s->opacityChanged = false;
- s->renderHintsChanged = false;
- s->clipChanged = false;
-
- return s;
-}
-
-QGL2PaintEngineState::QGL2PaintEngineState(QGL2PaintEngineState &other)
- : QPainterState(other)
-{
- isNew = true;
- needsClipBufferClear = other.needsClipBufferClear;
- clipTestEnabled = other.clipTestEnabled;
- currentClip = other.currentClip;
- canRestoreClip = other.canRestoreClip;
- rectangleClip = other.rectangleClip;
-}
-
-QGL2PaintEngineState::QGL2PaintEngineState()
-{
- isNew = true;
- needsClipBufferClear = true;
- clipTestEnabled = false;
- canRestoreClip = true;
-}
-
-QGL2PaintEngineState::~QGL2PaintEngineState()
-{
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h b/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
deleted file mode 100644
index 762aac2f65..0000000000
--- a/src/opengl/gl2paintengineex/qpaintengineex_opengl2_p.h
+++ /dev/null
@@ -1,334 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QPAINTENGINEEX_OPENGL2_P_H
-#define QPAINTENGINEEX_OPENGL2_P_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QDebug>
-
-#include <private/qpaintengineex_p.h>
-#include <private/qglengineshadermanager_p.h>
-#include <private/qgl2pexvertexarray_p.h>
-#include <private/qglpaintdevice_p.h>
-#include <private/qfontengine_p.h>
-#include <private/qdatabuffer_p.h>
-#include <private/qtriangulatingstroker_p.h>
-#include <private/qopenglextensions_p.h>
-
-enum EngineMode {
- ImageDrawingMode,
- TextDrawingMode,
- BrushDrawingMode,
- ImageArrayDrawingMode
-};
-
-QT_BEGIN_NAMESPACE
-
-#define GL_STENCIL_HIGH_BIT GLuint(0x80)
-#define QT_BRUSH_TEXTURE_UNIT GLuint(0)
-#define QT_IMAGE_TEXTURE_UNIT GLuint(0) //Can be the same as brush texture unit
-#define QT_MASK_TEXTURE_UNIT GLuint(1)
-#define QT_BACKGROUND_TEXTURE_UNIT GLuint(2)
-
-class QGL2PaintEngineExPrivate;
-
-
-class QGL2PaintEngineState : public QPainterState
-{
-public:
- QGL2PaintEngineState(QGL2PaintEngineState &other);
- QGL2PaintEngineState();
- ~QGL2PaintEngineState();
-
- uint isNew : 1;
- uint needsClipBufferClear : 1;
- uint clipTestEnabled : 1;
- uint canRestoreClip : 1;
- uint matrixChanged : 1;
- uint compositionModeChanged : 1;
- uint opacityChanged : 1;
- uint renderHintsChanged : 1;
- uint clipChanged : 1;
- uint currentClip : 8;
-
- QRect rectangleClip;
-};
-
-class Q_OPENGL_EXPORT QGL2PaintEngineEx : public QPaintEngineEx
-{
- Q_DECLARE_PRIVATE(QGL2PaintEngineEx)
-public:
- QGL2PaintEngineEx();
- ~QGL2PaintEngineEx();
-
- bool begin(QPaintDevice *device) override;
- void ensureActive();
- bool end() override;
-
- virtual void clipEnabledChanged() override;
- virtual void penChanged() override;
- virtual void brushChanged() override;
- virtual void brushOriginChanged() override;
- virtual void opacityChanged() override;
- virtual void compositionModeChanged() override;
- virtual void renderHintsChanged() override;
- virtual void transformChanged() override;
-
- virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) override;
- virtual void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
- QPainter::PixmapFragmentHints hints) override;
- virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr,
- Qt::ImageConversionFlags flags = Qt::AutoColor) override;
- virtual void drawTextItem(const QPointF &p, const QTextItem &textItem) override;
- virtual void fill(const QVectorPath &path, const QBrush &brush) override;
- virtual void stroke(const QVectorPath &path, const QPen &pen) override;
- virtual void clip(const QVectorPath &path, Qt::ClipOperation op) override;
-
- virtual void drawStaticTextItem(QStaticTextItem *textItem) override;
-
- bool drawTexture(const QRectF &r, GLuint textureId, const QSize &size, const QRectF &sr);
-
- Type type() const override { return OpenGL2; }
-
- virtual void setState(QPainterState *s) override;
- virtual QPainterState *createState(QPainterState *orig) const override;
- inline QGL2PaintEngineState *state() {
- return static_cast<QGL2PaintEngineState *>(QPaintEngineEx::state());
- }
- inline const QGL2PaintEngineState *state() const {
- return static_cast<const QGL2PaintEngineState *>(QPaintEngineEx::state());
- }
-
- void beginNativePainting() override;
- void endNativePainting() override;
-
- void invalidateState();
-
- void setRenderTextActive(bool);
-
- bool isNativePaintingActive() const;
- bool requiresPretransformedGlyphPositions(QFontEngine *, const QTransform &) const override { return false; }
- bool shouldDrawCachedGlyphs(QFontEngine *, const QTransform &) const override;
-
- void setTranslateZ(GLfloat z);
-
-private:
- Q_DISABLE_COPY_MOVE(QGL2PaintEngineEx)
-};
-
-class QGL2PaintEngineExPrivate : public QPaintEngineExPrivate, protected QOpenGLExtensions
-{
- Q_DECLARE_PUBLIC(QGL2PaintEngineEx)
-public:
- enum StencilFillMode {
- OddEvenFillMode,
- WindingFillMode,
- TriStripStrokeFillMode
- };
-
- QGL2PaintEngineExPrivate(QGL2PaintEngineEx *q_ptr) :
- q(q_ptr),
- shaderManager(nullptr),
- width(0), height(0),
- ctx(nullptr),
- useSystemClip(true),
- elementIndicesVBOId(0),
- opacityArray(0),
- snapToPixelGrid(false),
- nativePaintingActive(false),
- inverseScale(1),
- lastMaskTextureUsed(0),
- translateZ(0)
- { }
-
- ~QGL2PaintEngineExPrivate();
-
- void updateBrushTexture();
- void updateBrushUniforms();
- void updateMatrix();
- void updateCompositionMode();
- void updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id = GLuint(-1));
-
- void resetGLState();
- bool resetOpenGLContextActiveEngine();
-
- // fill, stroke, drawTexture, drawPixmaps & drawCachedGlyphs are the main rendering entry-points,
- // however writeClip can also be thought of as en entry point as it does similar things.
- void fill(const QVectorPath &path);
- void stroke(const QVectorPath &path, const QPen &pen);
- void drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern = false);
- void drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap,
- QPainter::PixmapFragmentHints hints);
- void drawCachedGlyphs(QFontEngine::GlyphFormat glyphFormat, QStaticTextItem *staticTextItem);
-
- // Calls glVertexAttributePointer if the pointer has changed
- inline void setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer);
-
- // draws whatever is in the vertex array:
- void drawVertexArrays(const float *data, int *stops, int stopCount, GLenum primitive);
- void drawVertexArrays(QGL2PEXVertexArray &vertexArray, GLenum primitive) {
- drawVertexArrays((const float *) vertexArray.data(), vertexArray.stops(), vertexArray.stopCount(), primitive);
- }
-
- // Composites the bounding rect onto dest buffer:
- void composite(const QGLRect& boundingRect);
-
- // Calls drawVertexArrays to render into stencil buffer:
- void fillStencilWithVertexArray(const float *data, int count, int *stops, int stopCount, const QGLRect &bounds, StencilFillMode mode);
- void fillStencilWithVertexArray(QGL2PEXVertexArray& vertexArray, bool useWindingFill) {
- fillStencilWithVertexArray((const float *) vertexArray.data(), 0, vertexArray.stops(), vertexArray.stopCount(),
- vertexArray.boundingRect(),
- useWindingFill ? WindingFillMode : OddEvenFillMode);
- }
-
- void setBrush(const QBrush& brush);
- void transferMode(EngineMode newMode);
- bool prepareForDraw(bool srcPixelsAreOpaque); // returns true if the program has changed
- bool prepareForCachedGlyphDraw(const QFontEngineGlyphCache &cache);
- inline void useSimpleShader();
- inline GLuint location(const QGLEngineShaderManager::Uniform uniform) {
- return shaderManager->getUniformLocation(uniform);
- }
-
- void clearClip(uint value);
- void writeClip(const QVectorPath &path, uint value);
- void resetClipIfNeeded();
-
- void updateClipScissorTest();
- void setScissor(const QRect &rect);
- void regenerateClip();
- void systemStateChanged() override;
-
-
- static QGLEngineShaderManager* shaderManagerForEngine(QGL2PaintEngineEx *engine) { return engine->d_func()->shaderManager; }
- static QGL2PaintEngineExPrivate *getData(QGL2PaintEngineEx *engine) { return engine->d_func(); }
- static void cleanupVectorPath(QPaintEngineEx *engine, void *data);
-
-
- QGL2PaintEngineEx* q;
- QGLEngineShaderManager* shaderManager;
- QGLPaintDevice* device;
- int width, height;
- QGLContext *ctx;
- EngineMode mode;
- QFontEngine::GlyphFormat glyphCacheFormat;
-
- // Dirty flags
- bool matrixDirty; // Implies matrix uniforms are also dirty
- bool compositionModeDirty;
- bool brushTextureDirty;
- bool brushUniformsDirty;
- bool opacityUniformDirty;
- bool matrixUniformDirty;
- bool translateZUniformDirty;
-
- bool stencilClean; // Has the stencil not been used for clipping so far?
- bool useSystemClip;
- QRegion dirtyStencilRegion;
- QRect currentScissorBounds;
- uint maxClip;
-
- QBrush currentBrush; // May not be the state's brush!
- const QBrush noBrush;
-
- QPixmap currentBrushPixmap;
-
- QGL2PEXVertexArray vertexCoordinateArray;
- QGL2PEXVertexArray textureCoordinateArray;
- QVector<GLushort> elementIndices;
- GLuint elementIndicesVBOId;
- QDataBuffer<GLfloat> opacityArray;
- GLfloat staticVertexCoordinateArray[8];
- GLfloat staticTextureCoordinateArray[8];
-
- bool snapToPixelGrid;
- bool nativePaintingActive;
- GLfloat pmvMatrix[3][3];
- GLfloat inverseScale;
-
- GLuint lastTextureUsed;
- GLuint lastMaskTextureUsed;
-
- bool needsSync;
- bool multisamplingAlwaysEnabled;
-
- GLfloat depthRange[2];
-
- float textureInvertedY;
-
- QTriangulatingStroker stroker;
- QDashedStrokeProcessor dasher;
-
- QSet<QVectorPath::CacheEntry *> pathCaches;
- QVector<GLuint> unusedVBOSToClean;
- QVector<GLuint> unusedIBOSToClean;
-
- const GLfloat *vertexAttribPointers[3];
-
- GLfloat translateZ;
-};
-
-
-void QGL2PaintEngineExPrivate::setVertexAttributePointer(unsigned int arrayIndex, const GLfloat *pointer)
-{
- Q_ASSERT(arrayIndex < 3);
- if (pointer == vertexAttribPointers[arrayIndex])
- return;
-
- vertexAttribPointers[arrayIndex] = pointer;
- if (arrayIndex == QT_OPACITY_ATTR)
- glVertexAttribPointer(arrayIndex, 1, GL_FLOAT, GL_FALSE, 0, pointer);
- else
- glVertexAttribPointer(arrayIndex, 2, GL_FLOAT, GL_FALSE, 0, pointer);
-}
-
-QT_END_NAMESPACE
-
-#endif // QPAINTENGINEEX_OPENGL2_P_H
diff --git a/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp b/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp
deleted file mode 100644
index d5ce4efd1a..0000000000
--- a/src/opengl/gl2paintengineex/qtextureglyphcache_gl.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qtextureglyphcache_gl_p.h"
-#include "qpaintengineex_opengl2_p.h"
-#include "qglfunctions.h"
-#include "private/qglengineshadersource_p.h"
-
-QT_BEGIN_NAMESPACE
-
-
-static int next_qgltextureglyphcache_serial_number()
-{
- static QBasicAtomicInt serial = Q_BASIC_ATOMIC_INITIALIZER(0);
- return 1 + serial.fetchAndAddRelaxed(1);
-}
-
-QGLTextureGlyphCache::QGLTextureGlyphCache(QFontEngine::GlyphFormat format, const QTransform &matrix)
- : QImageTextureGlyphCache(format, matrix)
- , m_textureResource(0)
- , pex(0)
- , m_blitProgram(0)
- , m_filterMode(Nearest)
- , m_serialNumber(next_qgltextureglyphcache_serial_number())
-{
-#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
- qDebug(" -> QGLTextureGlyphCache() %p for context %p.", this, QOpenGLContext::currentContext());
-#endif
- m_vertexCoordinateArray[0] = -1.0f;
- m_vertexCoordinateArray[1] = -1.0f;
- m_vertexCoordinateArray[2] = 1.0f;
- m_vertexCoordinateArray[3] = -1.0f;
- m_vertexCoordinateArray[4] = 1.0f;
- m_vertexCoordinateArray[5] = 1.0f;
- m_vertexCoordinateArray[6] = -1.0f;
- m_vertexCoordinateArray[7] = 1.0f;
-
- m_textureCoordinateArray[0] = 0.0f;
- m_textureCoordinateArray[1] = 0.0f;
- m_textureCoordinateArray[2] = 1.0f;
- m_textureCoordinateArray[3] = 0.0f;
- m_textureCoordinateArray[4] = 1.0f;
- m_textureCoordinateArray[5] = 1.0f;
- m_textureCoordinateArray[6] = 0.0f;
- m_textureCoordinateArray[7] = 1.0f;
-}
-
-QGLTextureGlyphCache::~QGLTextureGlyphCache()
-{
-#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
- qDebug(" -> ~QGLTextureGlyphCache() %p.", this);
-#endif
- delete m_blitProgram;
- if (m_textureResource)
- m_textureResource->free();
-}
-
-void QGLTextureGlyphCache::createTextureData(int width, int height)
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx == 0) {
- qWarning("QGLTextureGlyphCache::createTextureData: Called with no context");
- return;
- }
- QOpenGLFunctions *funcs = ctx->contextHandle()->functions();
-
- // create in QImageTextureGlyphCache baseclass is meant to be called
- // only to create the initial image and does not preserve the content,
- // so we don't call when this function is called from resize.
- if ((!QGLFramebufferObject::hasOpenGLFramebufferObjects() || ctx->d_ptr->workaround_brokenFBOReadBack) && image().isNull())
- QImageTextureGlyphCache::createTextureData(width, height);
-
- // Make the lower glyph texture size 16 x 16.
- if (width < 16)
- width = 16;
- if (height < 16)
- height = 16;
-
- if (m_textureResource && !m_textureResource->m_texture) {
- delete m_textureResource;
- m_textureResource = 0;
- }
-
- if (!m_textureResource)
- m_textureResource = new QGLGlyphTexture(ctx);
-
- funcs->glGenTextures(1, &m_textureResource->m_texture);
- funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
-
- m_textureResource->m_width = width;
- m_textureResource->m_height = height;
-
- if (m_format == QFontEngine::Format_A32) {
- QVarLengthArray<uchar> data(width * height * 4);
- for (int i = 0; i < data.size(); ++i)
- data[i] = 0;
- funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
- } else {
- QVarLengthArray<uchar> data(width * height);
- for (int i = 0; i < data.size(); ++i)
- data[i] = 0;
- funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);
- }
-
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- m_filterMode = Nearest;
-}
-
-void QGLTextureGlyphCache::resizeTextureData(int width, int height)
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx == 0) {
- qWarning("QGLTextureGlyphCache::resizeTextureData: Called with no context");
- return;
- }
- QOpenGLFunctions *funcs = ctx->contextHandle()->functions();
-
- int oldWidth = m_textureResource->m_width;
- int oldHeight = m_textureResource->m_height;
-
- // Make the lower glyph texture size 16 x 16.
- if (width < 16)
- width = 16;
- if (height < 16)
- height = 16;
-
- GLuint oldTexture = m_textureResource->m_texture;
- createTextureData(width, height);
-
- if (!QGLFramebufferObject::hasOpenGLFramebufferObjects() || ctx->d_ptr->workaround_brokenFBOReadBack) {
- QImageTextureGlyphCache::resizeTextureData(width, height);
- Q_ASSERT(image().depth() == 8);
- funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
- funcs->glDeleteTextures(1, &oldTexture);
- return;
- }
-
- // ### the QTextureGlyphCache API needs to be reworked to allow
- // ### resizeTextureData to fail
-
- ctx->d_ptr->refreshCurrentFbo();
-
- funcs->glBindFramebuffer(GL_FRAMEBUFFER, m_textureResource->m_fbo);
-
- GLuint tmp_texture;
- funcs->glGenTextures(1, &tmp_texture);
- funcs->glBindTexture(GL_TEXTURE_2D, tmp_texture);
- funcs->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, NULL);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- m_filterMode = Nearest;
- funcs->glBindTexture(GL_TEXTURE_2D, 0);
- funcs->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D, tmp_texture, 0);
-
- funcs->glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
- funcs->glBindTexture(GL_TEXTURE_2D, oldTexture);
-
- if (pex != 0)
- pex->transferMode(BrushDrawingMode);
-
- funcs->glDisable(GL_STENCIL_TEST);
- funcs->glDisable(GL_DEPTH_TEST);
- funcs->glDisable(GL_SCISSOR_TEST);
- funcs->glDisable(GL_BLEND);
-
- funcs->glViewport(0, 0, oldWidth, oldHeight);
-
- QGLShaderProgram *blitProgram = 0;
- if (pex == 0) {
- if (m_blitProgram == 0) {
- m_blitProgram = new QGLShaderProgram(ctx);
-
- {
- QString source;
- source.append(QLatin1String(qglslMainWithTexCoordsVertexShader));
- source.append(QLatin1String(qglslUntransformedPositionVertexShader));
-
- QGLShader *vertexShader = new QGLShader(QGLShader::Vertex, m_blitProgram);
- vertexShader->compileSourceCode(source);
-
- m_blitProgram->addShader(vertexShader);
- }
-
- {
- QString source;
- source.append(QLatin1String(qglslMainFragmentShader));
- source.append(QLatin1String(qglslImageSrcFragmentShader));
-
- QGLShader *fragmentShader = new QGLShader(QGLShader::Fragment, m_blitProgram);
- fragmentShader->compileSourceCode(source);
-
- m_blitProgram->addShader(fragmentShader);
- }
-
- m_blitProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
- m_blitProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
-
- m_blitProgram->link();
- }
-
- funcs->glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_vertexCoordinateArray);
- funcs->glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_textureCoordinateArray);
-
- m_blitProgram->bind();
- m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
- m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
- m_blitProgram->disableAttributeArray(int(QT_OPACITY_ATTR));
-
- blitProgram = m_blitProgram;
-
- } else {
- pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, m_vertexCoordinateArray);
- pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, m_textureCoordinateArray);
-
- pex->shaderManager->useBlitProgram();
- blitProgram = pex->shaderManager->blitProgram();
- }
-
- blitProgram->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
-
- funcs->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
- funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
-
- funcs->glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
-
- funcs->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_RENDERBUFFER, 0);
- funcs->glDeleteTextures(1, &tmp_texture);
- funcs->glDeleteTextures(1, &oldTexture);
-
- funcs->glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_ptr->current_fbo);
-
- if (pex != 0) {
- funcs->glViewport(0, 0, pex->width, pex->height);
- pex->updateClipScissorTest();
- }
-}
-
-void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph, QFixed subPixelPosition)
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx == 0) {
- qWarning("QGLTextureGlyphCache::fillTexture: Called with no context");
- return;
- }
- QOpenGLFunctions *funcs = ctx->contextHandle()->functions();
-
- if (!QGLFramebufferObject::hasOpenGLFramebufferObjects() || ctx->d_ptr->workaround_brokenFBOReadBack) {
- QImageTextureGlyphCache::fillTexture(c, glyph, subPixelPosition);
-
- funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
- const QImage &texture = image();
- const uchar *bits = texture.constBits();
- bits += c.y * texture.bytesPerLine() + c.x;
- for (int i=0; i<c.h; ++i) {
- funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, c.w, 1, GL_ALPHA, GL_UNSIGNED_BYTE, bits);
- bits += texture.bytesPerLine();
- }
- return;
- }
-
- QImage mask = textureMapForGlyph(glyph, subPixelPosition);
- const int maskWidth = mask.width();
- const int maskHeight = mask.height();
-
- if (mask.format() == QImage::Format_Mono) {
- mask = mask.convertToFormat(QImage::Format_Indexed8);
- for (int y = 0; y < maskHeight; ++y) {
- uchar *src = (uchar *) mask.scanLine(y);
- for (int x = 0; x < maskWidth; ++x)
- src[x] = -src[x]; // convert 0 and 1 into 0 and 255
- }
- } else if (mask.depth() == 32) {
- // Make the alpha component equal to the average of the RGB values.
- // This is needed when drawing sub-pixel antialiased text on translucent targets.
- for (int y = 0; y < maskHeight; ++y) {
- quint32 *src = (quint32 *) mask.scanLine(y);
- for (int x = 0; x < maskWidth; ++x) {
- int r = qRed(src[x]);
- int g = qGreen(src[x]);
- int b = qBlue(src[x]);
- int avg;
- if (mask.format() == QImage::Format_RGB32)
- avg = (r + g + b + 1) / 3; // "+1" for rounding.
- else // Format_ARGB_Premultiplied
- avg = qAlpha(src[x]);
- if (ctx->contextHandle()->isOpenGLES()) {
- // swizzle the bits to accommodate for the GL_RGBA upload.
- src[x] = (avg << 24) | (r << 0) | (g << 8) | (b << 16);
- } else {
- src[x] = (src[x] & 0x00ffffff) | (avg << 24);
- }
- }
- }
- }
-
- funcs->glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
- if (mask.depth() == 32) {
- GLenum format = GL_RGBA;
-#if !defined(QT_OPENGL_ES_2)
- if (!ctx->contextHandle()->isOpenGLES())
- format = GL_BGRA;
-#endif
- funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, format, GL_UNSIGNED_BYTE, mask.bits());
- } else {
- // glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is
- // not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista
- // and nVidia GeForce 8500GT. GL_UNPACK_ALIGNMENT is set to four bytes, 'mask' has a
- // multiple of four bytes per line, and most of the glyph shows up correctly in the
- // texture, which makes me think that this is a driver bug.
- // One workaround is to make sure the mask width is a multiple of four bytes, for instance
- // by converting it to a format with four bytes per pixel. Another is to copy one line at a
- // time.
-
- if (!ctx->d_ptr->workaround_brokenAlphaTexSubImage_init) {
- // don't know which driver versions exhibit this bug, so be conservative for now
- const QByteArray vendorString(reinterpret_cast<const char*>(funcs->glGetString(GL_VENDOR)));
- ctx->d_ptr->workaround_brokenAlphaTexSubImage = vendorString.indexOf("NVIDIA") >= 0;
- ctx->d_ptr->workaround_brokenAlphaTexSubImage_init = true;
- }
-
- if (ctx->d_ptr->workaround_brokenAlphaTexSubImage) {
- for (int i = 0; i < maskHeight; ++i)
- funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, maskWidth, 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));
- } else {
- funcs->glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_ALPHA, GL_UNSIGNED_BYTE, mask.bits());
- }
- }
-}
-
-int QGLTextureGlyphCache::glyphPadding() const
-{
- return 1;
-}
-
-int QGLTextureGlyphCache::maxTextureWidth() const
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx == 0)
- return QImageTextureGlyphCache::maxTextureWidth();
- else
- return ctx->d_ptr->maxTextureSize();
-}
-
-int QGLTextureGlyphCache::maxTextureHeight() const
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx == 0)
- return QImageTextureGlyphCache::maxTextureHeight();
-
- if (ctx->d_ptr->workaround_brokenTexSubImage)
- return qMin(1024, ctx->d_ptr->maxTextureSize());
- else
- return ctx->d_ptr->maxTextureSize();
-}
-
-void QGLTextureGlyphCache::clear()
-{
- m_textureResource->free();
- m_textureResource = 0;
-
- m_w = 0;
- m_h = 0;
- m_cx = 0;
- m_cy = 0;
- m_currentRowHeight = 0;
- coords.clear();
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h b/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h
deleted file mode 100644
index 7c12ce8998..0000000000
--- a/src/opengl/gl2paintengineex/qtextureglyphcache_gl_p.h
+++ /dev/null
@@ -1,171 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QTEXTUREGLYPHCACHE_GL_P_H
-#define QTEXTUREGLYPHCACHE_GL_P_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <private/qtextureglyphcache_p.h>
-#include <private/qgl_p.h>
-#include <qglshaderprogram.h>
-#include <qglframebufferobject.h>
-#include <qopenglfunctions.h>
-
-// #define QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
-
-QT_BEGIN_NAMESPACE
-
-class QGL2PaintEngineExPrivate;
-
-struct QGLGlyphTexture : public QOpenGLSharedResource
-{
- QGLGlyphTexture(const QGLContext *ctx)
- : QOpenGLSharedResource(ctx->contextHandle()->shareGroup())
- , m_fbo(0)
- , m_width(0)
- , m_height(0)
- {
- if (ctx && QGLFramebufferObject::hasOpenGLFramebufferObjects() && !ctx->d_ptr->workaround_brokenFBOReadBack)
- ctx->contextHandle()->functions()->glGenFramebuffers(1, &m_fbo);
-
-#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
- qDebug(" -> QGLGlyphTexture() %p for context %p.", this, ctx);
-#endif
- }
-
- void freeResource(QOpenGLContext *context) override
- {
- const QGLContext *ctx = QGLContext::fromOpenGLContext(context);
-#ifdef QT_GL_TEXTURE_GLYPH_CACHE_DEBUG
- qDebug("~QGLGlyphTexture() %p for context %p.", this, ctx);
-#else
- Q_UNUSED(ctx);
-#endif
- if (ctx && m_fbo)
- ctx->contextHandle()->functions()->glDeleteFramebuffers(1, &m_fbo);
- if (m_width || m_height)
- ctx->contextHandle()->functions()->glDeleteTextures(1, &m_texture);
- }
-
- void invalidateResource() override
- {
- m_texture = 0;
- m_fbo = 0;
- m_width = 0;
- m_height = 0;
- }
-
- GLuint m_texture;
- GLuint m_fbo;
- int m_width;
- int m_height;
-};
-
-class Q_OPENGL_EXPORT QGLTextureGlyphCache : public QImageTextureGlyphCache
-{
-public:
- QGLTextureGlyphCache(QFontEngine::GlyphFormat format, const QTransform &matrix);
- ~QGLTextureGlyphCache();
-
- virtual void createTextureData(int width, int height) override;
- virtual void resizeTextureData(int width, int height) override;
- virtual void fillTexture(const Coord &c, glyph_t glyph, QFixed subPixelPosition) override;
- virtual int glyphPadding() const override;
- virtual int maxTextureWidth() const override;
- virtual int maxTextureHeight() const override;
-
- inline GLuint texture() const {
- QGLTextureGlyphCache *that = const_cast<QGLTextureGlyphCache *>(this);
- QGLGlyphTexture *glyphTexture = that->m_textureResource;
- return glyphTexture ? glyphTexture->m_texture : 0;
- }
-
- inline int width() const {
- QGLTextureGlyphCache *that = const_cast<QGLTextureGlyphCache *>(this);
- QGLGlyphTexture *glyphTexture = that->m_textureResource;
- return glyphTexture ? glyphTexture->m_width : 0;
- }
- inline int height() const {
- QGLTextureGlyphCache *that = const_cast<QGLTextureGlyphCache *>(this);
- QGLGlyphTexture *glyphTexture = that->m_textureResource;
- return glyphTexture ? glyphTexture->m_height : 0;
- }
-
- inline void setPaintEnginePrivate(QGL2PaintEngineExPrivate *p) { pex = p; }
-
- inline const QOpenGLContextGroup *contextGroup() const { return m_textureResource ? m_textureResource->group() : nullptr; }
-
- inline int serialNumber() const { return m_serialNumber; }
-
- enum FilterMode {
- Nearest,
- Linear
- };
- FilterMode filterMode() const { return m_filterMode; }
- void setFilterMode(FilterMode m) { m_filterMode = m; }
-
- void clear();
-
-private:
- QGLGlyphTexture *m_textureResource;
-
- QGL2PaintEngineExPrivate *pex;
- QGLShaderProgram *m_blitProgram;
- FilterMode m_filterMode;
-
- GLfloat m_vertexCoordinateArray[8];
- GLfloat m_textureCoordinateArray[8];
-
- int m_serialNumber;
-};
-
-QT_END_NAMESPACE
-
-#endif
-
diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro
index 8b2349ff2f..811eecaeba 100644
--- a/src/opengl/opengl.pro
+++ b/src/opengl/opengl.pro
@@ -1,57 +1,14 @@
TARGET = QtOpenGL
-QT = core-private gui-private widgets-private
+QT = core-private gui-private
DEFINES += QT_NO_USING_NAMESPACE QT_NO_FOREACH
-msvc:equals(QT_ARCH, i386): QMAKE_LFLAGS += /BASE:0x63000000
-solaris-cc*:QMAKE_CXXFLAGS_RELEASE -= -O2
-
QMAKE_DOCS = $$PWD/doc/qtopengl.qdocconf
qtConfig(opengl): CONFIG += opengl
qtConfig(opengles2): CONFIG += opengles2
-HEADERS += qgl.h \
- qgl_p.h \
- qglcolormap.h \
- qglfunctions.h \
- qglpixelbuffer.h \
- qglpixelbuffer_p.h \
- qglframebufferobject.h \
- qglframebufferobject_p.h \
- qglpaintdevice_p.h \
- qglbuffer.h \
- qtopenglglobal.h
-
-SOURCES += qgl.cpp \
- qglcolormap.cpp \
- qglfunctions.cpp \
- qglpixelbuffer.cpp \
- qglframebufferobject.cpp \
- qglpaintdevice.cpp \
- qglbuffer.cpp \
-
-HEADERS += qglshaderprogram.h \
- gl2paintengineex/qglgradientcache_p.h \
- gl2paintengineex/qglengineshadermanager_p.h \
- gl2paintengineex/qgl2pexvertexarray_p.h \
- gl2paintengineex/qpaintengineex_opengl2_p.h \
- gl2paintengineex/qglengineshadersource_p.h \
- gl2paintengineex/qglcustomshaderstage_p.h \
- gl2paintengineex/qtextureglyphcache_gl_p.h \
- gl2paintengineex/qglshadercache_p.h
-
-SOURCES += qglshaderprogram.cpp \
- gl2paintengineex/qglgradientcache.cpp \
- gl2paintengineex/qglengineshadermanager.cpp \
- gl2paintengineex/qgl2pexvertexarray.cpp \
- gl2paintengineex/qpaintengineex_opengl2.cpp \
- gl2paintengineex/qglcustomshaderstage.cpp \
- gl2paintengineex/qtextureglyphcache_gl.cpp
-
-qtConfig(graphicseffect) {
- HEADERS += qgraphicsshadereffect_p.h
- SOURCES += qgraphicsshadereffect.cpp
-}
+HEADERS += \
+ qtopenglglobal.h
load(qt_module)
diff --git a/src/opengl/qgl.cpp b/src/opengl/qgl.cpp
deleted file mode 100644
index 4108b70094..0000000000
--- a/src/opengl/qgl.cpp
+++ /dev/null
@@ -1,5558 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qapplication.h"
-#include "qplatformdefs.h"
-#include "qgl.h"
-#include <qdebug.h>
-#include <qglfunctions.h>
-
-#include <qdatetime.h>
-
-#include <stdlib.h> // malloc
-
-#include "qpixmap.h"
-#include "qimage.h"
-#include "qgl_p.h"
-
-#include "gl2paintengineex/qpaintengineex_opengl2_p.h"
-
-#include <qpa/qplatformopenglcontext.h>
-
-#include <qglpixelbuffer.h>
-#include <qglframebufferobject.h>
-#include <private/qopenglextensions_p.h>
-
-#include <private/qimage_p.h>
-#include <qpa/qplatformpixmap.h>
-#include <private/qglpixelbuffer_p.h>
-#include <private/qimagepixmapcleanuphooks_p.h>
-#include "qcolormap.h"
-#include "qfile.h"
-#include <qmutex.h>
-
-#include "qsurfaceformat.h"
-#include <private/qapplication_p.h>
-#include <qpa/qplatformopenglcontext.h>
-#include <qpa/qplatformwindow.h>
-
-#ifndef QT_OPENGL_ES_2
-#include <qopenglfunctions_1_1.h>
-#endif
-
-// #define QT_GL_CONTEXT_RESOURCE_DEBUG
-
-QT_BEGIN_NAMESPACE
-
-class QGLDefaultExtensions
-{
-public:
- QGLDefaultExtensions()
- {
- QGLTemporaryContext tempContext;
- Q_ASSERT(QOpenGLContext::currentContext());
- QOpenGLExtensions *ext = qgl_extensions();
- Q_ASSERT(ext);
- extensions = ext->openGLExtensions();
- features = ext->openGLFeatures();
- }
-
- QOpenGLFunctions::OpenGLFeatures features;
- QOpenGLExtensions::OpenGLExtensions extensions;
-};
-
-Q_GLOBAL_STATIC(QGLDefaultExtensions, qtDefaultExtensions)
-
-bool qgl_hasFeature(QOpenGLFunctions::OpenGLFeature feature)
-{
- if (QOpenGLContext::currentContext())
- return QOpenGLContext::currentContext()->functions()->hasOpenGLFeature(feature);
- return qtDefaultExtensions()->features & feature;
-}
-
-bool qgl_hasExtension(QOpenGLExtensions::OpenGLExtension extension)
-{
- if (QOpenGLContext::currentContext())
- return qgl_extensions()->hasOpenGLExtension(extension);
- return qtDefaultExtensions()->extensions & extension;
-}
-
-QOpenGLExtensions::OpenGLExtensions extensions;
-
-/*
- Returns the GL extensions for the current QOpenGLContext. If there is no
- current QOpenGLContext, a default context will be created and the extensions
- for that context will be returned instead.
-*/
-QOpenGLExtensions* qgl_extensions()
-{
- if (QOpenGLContext *context = QOpenGLContext::currentContext())
- return static_cast<QOpenGLExtensions *>(context->functions());
-
- Q_ASSERT(false);
- return 0;
-}
-
-QOpenGLFunctions *qgl_functions()
-{
- return qgl_extensions(); // QOpenGLExtensions is just a subclass of QOpenGLFunctions
-}
-
-#ifndef QT_OPENGL_ES_2
-QOpenGLFunctions_1_1 *qgl1_functions()
-{
- QOpenGLFunctions_1_1 *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_1_1>();
- f->initializeOpenGLFunctions();
- return f;
-}
-#endif
-
-struct QGLThreadContext {
- ~QGLThreadContext() {
- if (context)
- context->doneCurrent();
- }
- QGLContext *context;
-};
-
-Q_GLOBAL_STATIC(QGLFormat, qgl_default_format)
-
-class QGLDefaultOverlayFormat: public QGLFormat
-{
-public:
- inline QGLDefaultOverlayFormat()
- {
- setOption(QGL::FormatOption(0xffffU << 16)); // turn off all options
- setOption(QGL::DirectRendering);
- setPlane(1);
- }
-};
-Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
-
-Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
-QGLSignalProxy *QGLSignalProxy::instance()
-{
- QGLSignalProxy *proxy = theSignalProxy();
- if (proxy && qApp && proxy->thread() != qApp->thread()) {
- if (proxy->thread() == QThread::currentThread())
- proxy->moveToThread(qApp->thread());
- }
- return proxy;
-}
-
-
-/*!
- \namespace QGL
- \inmodule QtOpenGL
-
- \brief The QGL namespace specifies miscellaneous identifiers used
- in the Qt OpenGL module.
-*/
-
-/*!
- \enum QGL::FormatOption
-
- This enum specifies the format options that can be used to configure an OpenGL
- context. These are set using QGLFormat::setOption().
-
- \value DoubleBuffer Specifies the use of double buffering.
- \value DepthBuffer Enables the use of a depth buffer.
- \value Rgba Specifies that the context should use RGBA as its pixel format.
- \value AlphaChannel Enables the use of an alpha channel.
- \value AccumBuffer Enables the use of an accumulation buffer.
- \value StencilBuffer Enables the use of a stencil buffer.
- \value StereoBuffers Enables the use of a stereo buffers for use with visualization hardware.
- \value DirectRendering Specifies that the context is used for direct rendering to a display.
- \value HasOverlay Enables the use of an overlay.
- \value SampleBuffers Enables the use of sample buffers.
- \value DeprecatedFunctions Enables the use of deprecated functionality for OpenGL 3.x
- contexts. A context with deprecated functionality enabled is
- called a full context in the OpenGL specification.
- \value SingleBuffer Specifies the use of a single buffer, as opposed to double buffers.
- \value NoDepthBuffer Disables the use of a depth buffer.
- \value ColorIndex Specifies that the context should use a color index as its pixel format.
- \value NoAlphaChannel Disables the use of an alpha channel.
- \value NoAccumBuffer Disables the use of an accumulation buffer.
- \value NoStencilBuffer Disables the use of a stencil buffer.
- \value NoStereoBuffers Disables the use of stereo buffers.
- \value IndirectRendering Specifies that the context is used for indirect rendering to a buffer.
- \value NoOverlay Disables the use of an overlay.
- \value NoSampleBuffers Disables the use of sample buffers.
- \value NoDeprecatedFunctions Disables the use of deprecated functionality for OpenGL 3.x
- contexts. A context with deprecated functionality disabled is
- called a forward compatible context in the OpenGL specification.
-*/
-
-/*****************************************************************************
- QGLFormat implementation
- *****************************************************************************/
-
-
-/*!
- \class QGLFormat
- \inmodule QtOpenGL
- \obsolete
-
- \brief The QGLFormat class specifies the display format of an OpenGL
- rendering context.
-
- A display format has several characteristics:
- \list
- \li \l{setDoubleBuffer()}{Double or single buffering.}
- \li \l{setDepth()}{Depth buffer.}
- \li \l{setRgba()}{RGBA or color index mode.}
- \li \l{setAlpha()}{Alpha channel.}
- \li \l{setAccum()}{Accumulation buffer.}
- \li \l{setStencil()}{Stencil buffer.}
- \li \l{setStereo()}{Stereo buffers.}
- \li \l{setDirectRendering()}{Direct rendering.}
- \li \l{setOverlay()}{Presence of an overlay.}
- \li \l{setPlane()}{Plane of an overlay.}
- \li \l{setSampleBuffers()}{Multisample buffers.}
- \endlist
-
- You can also specify preferred bit depths for the color buffer,
- depth buffer, alpha buffer, accumulation buffer and the stencil
- buffer with the functions: setRedBufferSize(), setGreenBufferSize(),
- setBlueBufferSize(), setDepthBufferSize(), setAlphaBufferSize(),
- setAccumBufferSize() and setStencilBufferSize().
-
- Note that even if you specify that you prefer a 32 bit depth
- buffer (e.g. with setDepthBufferSize(32)), the format that is
- chosen may not have a 32 bit depth buffer, even if there is a
- format available with a 32 bit depth buffer. The main reason for
- this is how the system dependant picking algorithms work on the
- different platforms, and some format options may have higher
- precedence than others.
-
- You create and tell a QGLFormat object what rendering options you
- want from an OpenGL rendering context.
-
- OpenGL drivers or accelerated hardware may or may not support
- advanced features such as alpha channel or stereographic viewing.
- If you request some features that the driver/hardware does not
- provide when you create a QGLWidget, you will get a rendering
- context with the nearest subset of features.
-
- There are different ways to define the display characteristics of
- a rendering context. One is to create a QGLFormat and make it the
- default for the entire application:
- \snippet code/src_opengl_qgl.cpp 0
-
- Or you can specify the desired format when creating an object of
- your QGLWidget subclass:
- \snippet code/src_opengl_qgl.cpp 1
-
- After the widget has been created, you can find out which of the
- requested features the system was able to provide:
- \snippet code/src_opengl_qgl.cpp 2
-
- \legalese
- OpenGL is a trademark of Silicon Graphics, Inc. in the
- United States and other countries.
- \endlegalese
-
- \sa QGLContext, QGLWidget
-*/
-
-#ifndef QT_OPENGL_ES
-
-static inline void transform_point(GLdouble out[4], const GLdouble m[16], const GLdouble in[4])
-{
-#define M(row,col) m[col*4+row]
- out[0] =
- M(0, 0) * in[0] + M(0, 1) * in[1] + M(0, 2) * in[2] + M(0, 3) * in[3];
- out[1] =
- M(1, 0) * in[0] + M(1, 1) * in[1] + M(1, 2) * in[2] + M(1, 3) * in[3];
- out[2] =
- M(2, 0) * in[0] + M(2, 1) * in[1] + M(2, 2) * in[2] + M(2, 3) * in[3];
- out[3] =
- M(3, 0) * in[0] + M(3, 1) * in[1] + M(3, 2) * in[2] + M(3, 3) * in[3];
-#undef M
-}
-
-static inline GLint qgluProject(GLdouble objx, GLdouble objy, GLdouble objz,
- const GLdouble model[16], const GLdouble proj[16],
- const GLint viewport[4],
- GLdouble * winx, GLdouble * winy, GLdouble * winz)
-{
- GLdouble in[4], out[4];
-
- in[0] = objx;
- in[1] = objy;
- in[2] = objz;
- in[3] = 1.0;
- transform_point(out, model, in);
- transform_point(in, proj, out);
-
- if (in[3] == 0.0)
- return GL_FALSE;
-
- in[0] /= in[3];
- in[1] /= in[3];
- in[2] /= in[3];
-
- *winx = viewport[0] + (1 + in[0]) * viewport[2] / 2;
- *winy = viewport[1] + (1 + in[1]) * viewport[3] / 2;
-
- *winz = (1 + in[2]) / 2;
- return GL_TRUE;
-}
-
-#endif // !QT_OPENGL_ES
-
-/*!
- Constructs a QGLFormat object with the following default settings:
- \list
- \li \l{setDoubleBuffer()}{Double buffer:} Enabled.
- \li \l{setDepth()}{Depth buffer:} Enabled.
- \li \l{setRgba()}{RGBA:} Enabled (i.e., color index disabled).
- \li \l{setAlpha()}{Alpha channel:} Disabled.
- \li \l{setAccum()}{Accumulator buffer:} Disabled.
- \li \l{setStencil()}{Stencil buffer:} Enabled.
- \li \l{setStereo()}{Stereo:} Disabled.
- \li \l{setDirectRendering()}{Direct rendering:} Enabled.
- \li \l{setOverlay()}{Overlay:} Disabled.
- \li \l{setPlane()}{Plane:} 0 (i.e., normal plane).
- \li \l{setSampleBuffers()}{Multisample buffers:} Disabled.
- \endlist
-*/
-
-QGLFormat::QGLFormat()
-{
- d = new QGLFormatPrivate;
-}
-
-
-/*!
- Creates a QGLFormat object that is a copy of the current
- defaultFormat().
-
- If \a options is not 0, the default format is modified by the
- specified format options. The \a options parameter should be
- QGL::FormatOption values OR'ed together.
-
- This constructor makes it easy to specify a certain desired format
- in classes derived from QGLWidget, for example:
- \snippet code/src_opengl_qgl.cpp 3
-
- Note that there are QGL::FormatOption values to turn format settings
- both on and off, e.g. QGL::DepthBuffer and QGL::NoDepthBuffer,
- QGL::DirectRendering and QGL::IndirectRendering, etc.
-
- The \a plane parameter defaults to 0 and is the plane which this
- format should be associated with. Not all OpenGL implementations
- supports overlay/underlay rendering planes.
-
- \sa defaultFormat(), setOption(), setPlane()
-*/
-
-QGLFormat::QGLFormat(QGL::FormatOptions options, int plane)
-{
- d = new QGLFormatPrivate;
- QGL::FormatOptions newOpts = options;
- d->opts = defaultFormat().d->opts;
- d->opts |= (newOpts & 0xffff);
- d->opts &= ~(newOpts >> 16);
- d->pln = plane;
-}
-
-/*!
- \internal
-*/
-void QGLFormat::detach()
-{
- if (d->ref.loadRelaxed() != 1) {
- QGLFormatPrivate *newd = new QGLFormatPrivate(d);
- if (!d->ref.deref())
- delete d;
- d = newd;
- }
-}
-
-/*!
- Constructs a copy of \a other.
-*/
-
-QGLFormat::QGLFormat(const QGLFormat &other)
-{
- d = other.d;
- d->ref.ref();
-}
-
-/*!
- Assigns \a other to this object.
-*/
-
-QGLFormat &QGLFormat::operator=(const QGLFormat &other)
-{
- if (d != other.d) {
- other.d->ref.ref();
- if (!d->ref.deref())
- delete d;
- d = other.d;
- }
- return *this;
-}
-
-/*!
- Destroys the QGLFormat.
-*/
-QGLFormat::~QGLFormat()
-{
- if (!d->ref.deref())
- delete d;
-}
-
-/*!
- Returns an OpenGL format for the window format specified by \a format.
-*/
-QGLFormat QGLFormat::fromSurfaceFormat(const QSurfaceFormat &format)
-{
- QGLFormat retFormat;
- if (format.alphaBufferSize() >= 0)
- retFormat.setAlphaBufferSize(format.alphaBufferSize());
- if (format.blueBufferSize() >= 0)
- retFormat.setBlueBufferSize(format.blueBufferSize());
- if (format.greenBufferSize() >= 0)
- retFormat.setGreenBufferSize(format.greenBufferSize());
- if (format.redBufferSize() >= 0)
- retFormat.setRedBufferSize(format.redBufferSize());
- if (format.depthBufferSize() >= 0)
- retFormat.setDepthBufferSize(format.depthBufferSize());
- if (format.samples() > 1) {
- retFormat.setSampleBuffers(true);
- retFormat.setSamples(format.samples());
- }
- if (format.stencilBufferSize() > 0) {
- retFormat.setStencil(true);
- retFormat.setStencilBufferSize(format.stencilBufferSize());
- }
- retFormat.setSwapInterval(format.swapInterval());
- retFormat.setDoubleBuffer(format.swapBehavior() != QSurfaceFormat::SingleBuffer);
- retFormat.setStereo(format.stereo());
- retFormat.setVersion(format.majorVersion(), format.minorVersion());
- retFormat.setProfile(static_cast<QGLFormat::OpenGLContextProfile>(format.profile()));
- return retFormat;
-}
-
-/*!
- Returns a window format for the OpenGL format specified by \a format.
-*/
-QSurfaceFormat QGLFormat::toSurfaceFormat(const QGLFormat &format)
-{
- QSurfaceFormat retFormat;
- if (format.alpha())
- retFormat.setAlphaBufferSize(format.alphaBufferSize() == -1 ? 1 : format.alphaBufferSize());
- if (format.blueBufferSize() >= 0)
- retFormat.setBlueBufferSize(format.blueBufferSize());
- if (format.greenBufferSize() >= 0)
- retFormat.setGreenBufferSize(format.greenBufferSize());
- if (format.redBufferSize() >= 0)
- retFormat.setRedBufferSize(format.redBufferSize());
- if (format.depth())
- retFormat.setDepthBufferSize(format.depthBufferSize() == -1 ? 1 : format.depthBufferSize());
- retFormat.setSwapBehavior(format.doubleBuffer() ? QSurfaceFormat::DoubleBuffer : QSurfaceFormat::SingleBuffer);
- if (format.sampleBuffers())
- retFormat.setSamples(format.samples() == -1 ? 4 : format.samples());
- if (format.stencil())
- retFormat.setStencilBufferSize(format.stencilBufferSize() == -1 ? 1 : format.stencilBufferSize());
- retFormat.setSwapInterval(format.swapInterval());
- retFormat.setStereo(format.stereo());
- retFormat.setMajorVersion(format.majorVersion());
- retFormat.setMinorVersion(format.minorVersion());
- retFormat.setProfile(static_cast<QSurfaceFormat::OpenGLContextProfile>(format.profile()));
- // QGLFormat has no way to set DeprecatedFunctions, that is, to tell that forward
- // compatibility should not be requested. Some drivers fail to ignore the fwdcompat
- // bit with compatibility profiles so make sure it is not set.
- if (format.profile() == QGLFormat::CompatibilityProfile)
- retFormat.setOption(QSurfaceFormat::DeprecatedFunctions);
- return retFormat;
-}
-
-void QGLContextPrivate::setupSharing() {
- Q_Q(QGLContext);
- QOpenGLContext *sharedContext = guiGlContext->shareContext();
- if (sharedContext) {
- QGLContext *actualSharedContext = QGLContext::fromOpenGLContext(sharedContext);
- sharing = true;
- QGLContextGroup::addShare(q, actualSharedContext);
- }
-}
-
-void QGLContextPrivate::refreshCurrentFbo()
-{
- QOpenGLContextPrivate *guiGlContextPrivate =
- guiGlContext ? QOpenGLContextPrivate::get(guiGlContext) : 0;
-
- // if QOpenGLFramebufferObjects have been used in the mean-time, we've lost our cached value
- if (guiGlContextPrivate && guiGlContextPrivate->qgl_current_fbo_invalid) {
- GLint current;
- QOpenGLFunctions *funcs = qgl_functions();
- funcs->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &current);
-
- current_fbo = current;
-
- guiGlContextPrivate->qgl_current_fbo_invalid = false;
- }
-}
-
-void QGLContextPrivate::setCurrentFbo(GLuint fbo)
-{
- current_fbo = fbo;
-
- QOpenGLContextPrivate *guiGlContextPrivate =
- guiGlContext ? QOpenGLContextPrivate::get(guiGlContext) : 0;
-
- if (guiGlContextPrivate)
- guiGlContextPrivate->qgl_current_fbo_invalid = false;
-}
-
-
-/*!
- \fn bool QGLFormat::doubleBuffer() const
-
- Returns \c true if double buffering is enabled; otherwise returns
- false. Double buffering is enabled by default.
-
- \sa setDoubleBuffer()
-*/
-
-/*!
- If \a enable is true sets double buffering; otherwise sets single
- buffering.
-
- Double buffering is enabled by default.
-
- Double buffering is a technique where graphics are rendered on an
- off-screen buffer and not directly to the screen. When the drawing
- has been completed, the program calls a swapBuffers() function to
- exchange the screen contents with the buffer. The result is
- flicker-free drawing and often better performance.
-
- Note that single buffered contexts are currently not supported
- with EGL.
-
- \sa doubleBuffer(), QGLContext::swapBuffers(),
- QGLWidget::swapBuffers()
-*/
-
-void QGLFormat::setDoubleBuffer(bool enable)
-{
- setOption(enable ? QGL::DoubleBuffer : QGL::SingleBuffer);
-}
-
-
-/*!
- \fn bool QGLFormat::depth() const
-
- Returns \c true if the depth buffer is enabled; otherwise returns
- false. The depth buffer is enabled by default.
-
- \sa setDepth(), setDepthBufferSize()
-*/
-
-/*!
- If \a enable is true enables the depth buffer; otherwise disables
- the depth buffer.
-
- The depth buffer is enabled by default.
-
- The purpose of a depth buffer (or Z-buffering) is to remove hidden
- surfaces. Pixels are assigned Z values based on the distance to
- the viewer. A pixel with a high Z value is closer to the viewer
- than a pixel with a low Z value. This information is used to
- decide whether to draw a pixel or not.
-
- \sa depth(), setDepthBufferSize()
-*/
-
-void QGLFormat::setDepth(bool enable)
-{
- setOption(enable ? QGL::DepthBuffer : QGL::NoDepthBuffer);
-}
-
-
-/*!
- \fn bool QGLFormat::rgba() const
-
- Returns \c true if RGBA color mode is set. Returns \c false if color
- index mode is set. The default color mode is RGBA.
-
- \sa setRgba()
-*/
-
-/*!
- If \a enable is true sets RGBA mode. If \a enable is false sets
- color index mode.
-
- The default color mode is RGBA.
-
- RGBA is the preferred mode for most OpenGL applications. In RGBA
- color mode you specify colors as red + green + blue + alpha
- quadruplets.
-
- In color index mode you specify an index into a color lookup
- table.
-
- \sa rgba()
-*/
-
-void QGLFormat::setRgba(bool enable)
-{
- setOption(enable ? QGL::Rgba : QGL::ColorIndex);
-}
-
-
-/*!
- \fn bool QGLFormat::alpha() const
-
- Returns \c true if the alpha buffer in the framebuffer is enabled;
- otherwise returns \c false. The alpha buffer is disabled by default.
-
- \sa setAlpha(), setAlphaBufferSize()
-*/
-
-/*!
- If \a enable is true enables the alpha buffer; otherwise disables
- the alpha buffer.
-
- The alpha buffer is disabled by default.
-
- The alpha buffer is typically used for implementing transparency
- or translucency. The A in RGBA specifies the transparency of a
- pixel.
-
- \sa alpha(), setAlphaBufferSize()
-*/
-
-void QGLFormat::setAlpha(bool enable)
-{
- setOption(enable ? QGL::AlphaChannel : QGL::NoAlphaChannel);
-}
-
-
-/*!
- \fn bool QGLFormat::accum() const
-
- Returns \c true if the accumulation buffer is enabled; otherwise
- returns \c false. The accumulation buffer is disabled by default.
-
- \sa setAccum(), setAccumBufferSize()
-*/
-
-/*!
- If \a enable is true enables the accumulation buffer; otherwise
- disables the accumulation buffer.
-
- The accumulation buffer is disabled by default.
-
- The accumulation buffer is used to create blur effects and
- multiple exposures.
-
- \sa accum(), setAccumBufferSize()
-*/
-
-void QGLFormat::setAccum(bool enable)
-{
- setOption(enable ? QGL::AccumBuffer : QGL::NoAccumBuffer);
-}
-
-
-/*!
- \fn bool QGLFormat::stencil() const
-
- Returns \c true if the stencil buffer is enabled; otherwise returns
- false. The stencil buffer is enabled by default.
-
- \sa setStencil(), setStencilBufferSize()
-*/
-
-/*!
- If \a enable is true enables the stencil buffer; otherwise
- disables the stencil buffer.
-
- The stencil buffer is enabled by default.
-
- The stencil buffer masks certain parts of the drawing area so that
- masked parts are not drawn on.
-
- \sa stencil(), setStencilBufferSize()
-*/
-
-void QGLFormat::setStencil(bool enable)
-{
- setOption(enable ? QGL::StencilBuffer: QGL::NoStencilBuffer);
-}
-
-
-/*!
- \fn bool QGLFormat::stereo() const
-
- Returns \c true if stereo buffering is enabled; otherwise returns
- false. Stereo buffering is disabled by default.
-
- \sa setStereo()
-*/
-
-/*!
- If \a enable is true enables stereo buffering; otherwise disables
- stereo buffering.
-
- Stereo buffering is disabled by default.
-
- Stereo buffering provides extra color buffers to generate left-eye
- and right-eye images.
-
- \sa stereo()
-*/
-
-void QGLFormat::setStereo(bool enable)
-{
- setOption(enable ? QGL::StereoBuffers : QGL::NoStereoBuffers);
-}
-
-
-/*!
- \fn bool QGLFormat::directRendering() const
-
- Returns \c true if direct rendering is enabled; otherwise returns
- false.
-
- Direct rendering is enabled by default.
-
- \sa setDirectRendering()
-*/
-
-/*!
- If \a enable is true enables direct rendering; otherwise disables
- direct rendering.
-
- Direct rendering is enabled by default.
-
- Enabling this option will make OpenGL bypass the underlying window
- system and render directly from hardware to the screen, if this is
- supported by the system.
-
- \sa directRendering()
-*/
-
-void QGLFormat::setDirectRendering(bool enable)
-{
- setOption(enable ? QGL::DirectRendering : QGL::IndirectRendering);
-}
-
-/*!
- \fn bool QGLFormat::sampleBuffers() const
-
- Returns \c true if multisample buffer support is enabled; otherwise
- returns \c false.
-
- The multisample buffer is disabled by default.
-
- \sa setSampleBuffers()
-*/
-
-/*!
- If \a enable is true, a GL context with multisample buffer support
- is picked; otherwise ignored.
-
- \sa sampleBuffers(), setSamples(), samples()
-*/
-void QGLFormat::setSampleBuffers(bool enable)
-{
- setOption(enable ? QGL::SampleBuffers : QGL::NoSampleBuffers);
-}
-
-/*!
- Returns the number of samples per pixel when multisampling is
- enabled. By default, the highest number of samples that is
- available is used.
-
- \sa setSampleBuffers(), sampleBuffers(), setSamples()
-*/
-int QGLFormat::samples() const
-{
- return d->numSamples;
-}
-
-/*!
- Set the preferred number of samples per pixel when multisampling
- is enabled to \a numSamples. By default, the highest number of
- samples available is used.
-
- \sa setSampleBuffers(), sampleBuffers(), samples()
-*/
-void QGLFormat::setSamples(int numSamples)
-{
- detach();
- if (numSamples < 0) {
- qWarning("QGLFormat::setSamples: Cannot have negative number of samples per pixel %d", numSamples);
- return;
- }
- d->numSamples = numSamples;
- setSampleBuffers(numSamples > 0);
-}
-
-/*!
- \since 4.2
-
- Set the preferred swap interval. This can be used to sync the GL
- drawing into a system window to the vertical refresh of the screen.
- Setting an \a interval value of 0 will turn the vertical refresh syncing
- off, any value higher than 0 will turn the vertical syncing on.
-
- Under Windows and under X11, where the \c{WGL_EXT_swap_control}
- and \c{GLX_SGI_video_sync} extensions are used, the \a interval
- parameter can be used to set the minimum number of video frames
- that are displayed before a buffer swap will occur. In effect,
- setting the \a interval to 10, means there will be 10 vertical
- retraces between every buffer swap.
-
- Under Windows the \c{WGL_EXT_swap_control} extension has to be present,
- and under X11 the \c{GLX_SGI_video_sync} extension has to be present.
-*/
-void QGLFormat::setSwapInterval(int interval)
-{
- detach();
- d->swapInterval = interval;
-}
-
-/*!
- \since 4.2
-
- Returns the currently set swap interval. -1 is returned if setting
- the swap interval isn't supported in the system GL implementation.
-*/
-int QGLFormat::swapInterval() const
-{
- return d->swapInterval;
-}
-
-/*!
- \fn bool QGLFormat::hasOverlay() const
-
- Returns \c true if overlay plane is enabled; otherwise returns \c false.
-
- Overlay is disabled by default.
-
- \sa setOverlay()
-*/
-
-/*!
- If \a enable is true enables an overlay plane; otherwise disables
- the overlay plane.
-
- Enabling the overlay plane will cause QGLWidget to create an
- additional context in an overlay plane. See the QGLWidget
- documentation for further information.
-
- \sa hasOverlay()
-*/
-
-void QGLFormat::setOverlay(bool enable)
-{
- setOption(enable ? QGL::HasOverlay : QGL::NoOverlay);
-}
-
-/*!
- Returns the plane of this format. The default for normal formats
- is 0, which means the normal plane. The default for overlay
- formats is 1, which is the first overlay plane.
-
- \sa setPlane(), defaultOverlayFormat()
-*/
-int QGLFormat::plane() const
-{
- return d->pln;
-}
-
-/*!
- Sets the requested plane to \a plane. 0 is the normal plane, 1 is
- the first overlay plane, 2 is the second overlay plane, etc.; -1,
- -2, etc. are underlay planes.
-
- Note that in contrast to other format specifications, the plane
- specifications will be matched exactly. This means that if you
- specify a plane that the underlying OpenGL system cannot provide,
- an \l{QGLWidget::isValid()}{invalid} QGLWidget will be
- created.
-
- \sa plane()
-*/
-void QGLFormat::setPlane(int plane)
-{
- detach();
- d->pln = plane;
-}
-
-/*!
- Sets the format option to \a opt.
-
- \sa testOption()
-*/
-
-void QGLFormat::setOption(QGL::FormatOptions opt)
-{
- detach();
- if (opt & 0xffff)
- d->opts |= opt;
- else
- d->opts &= ~(opt >> 16);
-}
-
-
-
-/*!
- Returns \c true if format option \a opt is set; otherwise returns \c false.
-
- \sa setOption()
-*/
-
-bool QGLFormat::testOption(QGL::FormatOptions opt) const
-{
- if (opt & 0xffff)
- return (d->opts & opt) != 0;
- else
- return (d->opts & (opt >> 16)) == 0;
-}
-
-/*!
- Set the minimum depth buffer size to \a size.
-
- \sa depthBufferSize(), setDepth(), depth()
-*/
-void QGLFormat::setDepthBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setDepthBufferSize: Cannot set negative depth buffer size %d", size);
- return;
- }
- d->depthSize = size;
- setDepth(size > 0);
-}
-
-/*!
- Returns the depth buffer size.
-
- \sa depth(), setDepth(), setDepthBufferSize()
-*/
-int QGLFormat::depthBufferSize() const
-{
- return d->depthSize;
-}
-
-/*!
- \since 4.2
-
- Set the preferred red buffer size to \a size.
-
- \sa setGreenBufferSize(), setBlueBufferSize(), setAlphaBufferSize()
-*/
-void QGLFormat::setRedBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setRedBufferSize: Cannot set negative red buffer size %d", size);
- return;
- }
- d->redSize = size;
-}
-
-/*!
- \since 4.2
-
- Returns the red buffer size.
-
- \sa setRedBufferSize()
-*/
-int QGLFormat::redBufferSize() const
-{
- return d->redSize;
-}
-
-/*!
- \since 4.2
-
- Set the preferred green buffer size to \a size.
-
- \sa setRedBufferSize(), setBlueBufferSize(), setAlphaBufferSize()
-*/
-void QGLFormat::setGreenBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setGreenBufferSize: Cannot set negative green buffer size %d", size);
- return;
- }
- d->greenSize = size;
-}
-
-/*!
- \since 4.2
-
- Returns the green buffer size.
-
- \sa setGreenBufferSize()
-*/
-int QGLFormat::greenBufferSize() const
-{
- return d->greenSize;
-}
-
-/*!
- \since 4.2
-
- Set the preferred blue buffer size to \a size.
-
- \sa setRedBufferSize(), setGreenBufferSize(), setAlphaBufferSize()
-*/
-void QGLFormat::setBlueBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setBlueBufferSize: Cannot set negative blue buffer size %d", size);
- return;
- }
- d->blueSize = size;
-}
-
-/*!
- \since 4.2
-
- Returns the blue buffer size.
-
- \sa setBlueBufferSize()
-*/
-int QGLFormat::blueBufferSize() const
-{
- return d->blueSize;
-}
-
-/*!
- Set the preferred alpha buffer size to \a size.
- This function implicitly enables the alpha channel.
-
- \sa setRedBufferSize(), setGreenBufferSize(), alphaBufferSize()
-*/
-void QGLFormat::setAlphaBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setAlphaBufferSize: Cannot set negative alpha buffer size %d", size);
- return;
- }
- d->alphaSize = size;
- setAlpha(size > 0);
-}
-
-/*!
- Returns the alpha buffer size.
-
- \sa alpha(), setAlpha(), setAlphaBufferSize()
-*/
-int QGLFormat::alphaBufferSize() const
-{
- return d->alphaSize;
-}
-
-/*!
- Set the preferred accumulation buffer size, where \a size is the
- bit depth for each RGBA component.
-
- \sa accum(), setAccum(), accumBufferSize()
-*/
-void QGLFormat::setAccumBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setAccumBufferSize: Cannot set negative accumulate buffer size %d", size);
- return;
- }
- d->accumSize = size;
- setAccum(size > 0);
-}
-
-/*!
- Returns the accumulation buffer size.
-
- \sa setAccumBufferSize(), accum(), setAccum()
-*/
-int QGLFormat::accumBufferSize() const
-{
- return d->accumSize;
-}
-
-/*!
- Set the preferred stencil buffer size to \a size.
-
- \sa stencilBufferSize(), setStencil(), stencil()
-*/
-void QGLFormat::setStencilBufferSize(int size)
-{
- detach();
- if (size < 0) {
- qWarning("QGLFormat::setStencilBufferSize: Cannot set negative stencil buffer size %d", size);
- return;
- }
- d->stencilSize = size;
- setStencil(size > 0);
-}
-
-/*!
- Returns the stencil buffer size.
-
- \sa stencil(), setStencil(), setStencilBufferSize()
-*/
-int QGLFormat::stencilBufferSize() const
-{
- return d->stencilSize;
-}
-
-/*!
- \since 4.7
-
- Set the OpenGL version to the \a major and \a minor numbers. If a
- context compatible with the requested OpenGL version cannot be
- created, a context compatible with version 1.x is created instead.
-
- \sa majorVersion(), minorVersion()
-*/
-void QGLFormat::setVersion(int major, int minor)
-{
- if (major < 1 || minor < 0) {
- qWarning("QGLFormat::setVersion: Cannot set zero or negative version number %d.%d", major, minor);
- return;
- }
- detach();
- d->majorVersion = major;
- d->minorVersion = minor;
-}
-
-/*!
- \since 4.7
-
- Returns the OpenGL major version.
-
- \sa setVersion(), minorVersion()
-*/
-int QGLFormat::majorVersion() const
-{
- return d->majorVersion;
-}
-
-/*!
- \since 4.7
-
- Returns the OpenGL minor version.
-
- \sa setVersion(), majorVersion()
-*/
-int QGLFormat::minorVersion() const
-{
- return d->minorVersion;
-}
-
-/*!
- \enum QGLFormat::OpenGLContextProfile
- \since 4.7
-
- This enum describes the OpenGL context profiles that can be
- specified for contexts implementing OpenGL version 3.2 or
- higher. These profiles are different from OpenGL ES profiles.
-
- \value NoProfile OpenGL version is lower than 3.2.
- \value CoreProfile Functionality deprecated in OpenGL version 3.0 is not available.
- \value CompatibilityProfile Functionality from earlier OpenGL versions is available.
-*/
-
-/*!
- \since 4.7
-
- Set the OpenGL context profile to \a profile. The \a profile is
- ignored if the requested OpenGL version is less than 3.2.
-
- \sa profile()
-*/
-void QGLFormat::setProfile(OpenGLContextProfile profile)
-{
- detach();
- d->profile = profile;
-}
-
-/*!
- \since 4.7
-
- Returns the OpenGL context profile.
-
- \sa setProfile()
-*/
-QGLFormat::OpenGLContextProfile QGLFormat::profile() const
-{
- return d->profile;
-}
-
-
-/*!
- \fn bool QGLFormat::hasOpenGL()
-
- Returns \c true if the window system has any OpenGL support;
- otherwise returns \c false.
-
- \warning This function must not be called until the QApplication
- object has been created.
-*/
-bool QGLFormat::hasOpenGL()
-{
- return QApplicationPrivate::platformIntegration()
- ->hasCapability(QPlatformIntegration::OpenGL);
-}
-
-/*!
- \fn bool QGLFormat::hasOpenGLOverlays()
-
- Returns \c true if the window system supports OpenGL overlays;
- otherwise returns \c false.
-
- \warning This function must not be called until the QApplication
- object has been created.
-*/
-bool QGLFormat::hasOpenGLOverlays()
-{
- return false;
-}
-
-QGLFormat::OpenGLVersionFlags Q_AUTOTEST_EXPORT qOpenGLVersionFlagsFromString(const QString &versionString)
-{
- QGLFormat::OpenGLVersionFlags versionFlags = QGLFormat::OpenGL_Version_None;
-
- if (versionString.startsWith(QLatin1String("OpenGL ES"))) {
- const auto parts = versionString.splitRef(QLatin1Char(' '));
- if (parts.size() >= 3) {
- if (parts[2].startsWith(QLatin1String("1."))) {
- if (parts[1].endsWith(QLatin1String("-CM"))) {
- versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_0 |
- QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
- if (parts[2].startsWith(QLatin1String("1.1")))
- versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_1 |
- QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
- } else {
- // Not -CM, must be CL, CommonLite
- versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
- if (parts[2].startsWith(QLatin1String("1.1")))
- versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
- }
- } else {
- // OpenGL ES version 2.0 or higher
- versionFlags |= QGLFormat::OpenGL_ES_Version_2_0;
- }
- } else {
- // if < 3 parts to the name, it is an unrecognised OpenGL ES
- qWarning("Unrecognised OpenGL ES version");
- }
- } else {
- // not ES, regular OpenGL, the version numbers are first in the string
- if (versionString.startsWith(QLatin1String("1."))) {
- switch (versionString[2].toLatin1()) {
- case '5':
- versionFlags |= QGLFormat::OpenGL_Version_1_5;
- Q_FALLTHROUGH();
- case '4':
- versionFlags |= QGLFormat::OpenGL_Version_1_4;
- Q_FALLTHROUGH();
- case '3':
- versionFlags |= QGLFormat::OpenGL_Version_1_3;
- Q_FALLTHROUGH();
- case '2':
- versionFlags |= QGLFormat::OpenGL_Version_1_2;
- Q_FALLTHROUGH();
- case '1':
- versionFlags |= QGLFormat::OpenGL_Version_1_1;
- Q_FALLTHROUGH();
- default:
- break;
- }
- } else if (versionString.startsWith(QLatin1String("2."))) {
- versionFlags |= QGLFormat::OpenGL_Version_1_1 |
- QGLFormat::OpenGL_Version_1_2 |
- QGLFormat::OpenGL_Version_1_3 |
- QGLFormat::OpenGL_Version_1_4 |
- QGLFormat::OpenGL_Version_1_5 |
- QGLFormat::OpenGL_Version_2_0;
- if (versionString[2].toLatin1() == '1')
- versionFlags |= QGLFormat::OpenGL_Version_2_1;
- } else if (versionString.startsWith(QLatin1String("3."))) {
- versionFlags |= QGLFormat::OpenGL_Version_1_1 |
- QGLFormat::OpenGL_Version_1_2 |
- QGLFormat::OpenGL_Version_1_3 |
- QGLFormat::OpenGL_Version_1_4 |
- QGLFormat::OpenGL_Version_1_5 |
- QGLFormat::OpenGL_Version_2_0 |
- QGLFormat::OpenGL_Version_2_1 |
- QGLFormat::OpenGL_Version_3_0;
- switch (versionString[2].toLatin1()) {
- case '3':
- versionFlags |= QGLFormat::OpenGL_Version_3_3;
- Q_FALLTHROUGH();
- case '2':
- versionFlags |= QGLFormat::OpenGL_Version_3_2;
- Q_FALLTHROUGH();
- case '1':
- versionFlags |= QGLFormat::OpenGL_Version_3_1;
- Q_FALLTHROUGH();
- case '0':
- break;
- default:
- versionFlags |= QGLFormat::OpenGL_Version_3_1 |
- QGLFormat::OpenGL_Version_3_2 |
- QGLFormat::OpenGL_Version_3_3;
- break;
- }
- } else if (versionString.startsWith(QLatin1String("4."))) {
- versionFlags |= QGLFormat::OpenGL_Version_1_1 |
- QGLFormat::OpenGL_Version_1_2 |
- QGLFormat::OpenGL_Version_1_3 |
- QGLFormat::OpenGL_Version_1_4 |
- QGLFormat::OpenGL_Version_1_5 |
- QGLFormat::OpenGL_Version_2_0 |
- QGLFormat::OpenGL_Version_2_1 |
- QGLFormat::OpenGL_Version_3_0 |
- QGLFormat::OpenGL_Version_3_1 |
- QGLFormat::OpenGL_Version_3_2 |
- QGLFormat::OpenGL_Version_3_3 |
- QGLFormat::OpenGL_Version_4_0;
- switch (versionString[2].toLatin1()) {
- case '3':
- versionFlags |= QGLFormat::OpenGL_Version_4_3;
- Q_FALLTHROUGH();
- case '2':
- versionFlags |= QGLFormat::OpenGL_Version_4_2;
- Q_FALLTHROUGH();
- case '1':
- versionFlags |= QGLFormat::OpenGL_Version_4_1;
- Q_FALLTHROUGH();
- case '0':
- break;
- default:
- versionFlags |= QGLFormat::OpenGL_Version_4_1 |
- QGLFormat::OpenGL_Version_4_2 |
- QGLFormat::OpenGL_Version_4_3;
- break;
- }
- } else {
- versionFlags |= QGLFormat::OpenGL_Version_1_1 |
- QGLFormat::OpenGL_Version_1_2 |
- QGLFormat::OpenGL_Version_1_3 |
- QGLFormat::OpenGL_Version_1_4 |
- QGLFormat::OpenGL_Version_1_5 |
- QGLFormat::OpenGL_Version_2_0 |
- QGLFormat::OpenGL_Version_2_1 |
- QGLFormat::OpenGL_Version_3_0 |
- QGLFormat::OpenGL_Version_3_1 |
- QGLFormat::OpenGL_Version_3_2 |
- QGLFormat::OpenGL_Version_3_3 |
- QGLFormat::OpenGL_Version_4_0 |
- QGLFormat::OpenGL_Version_4_1 |
- QGLFormat::OpenGL_Version_4_2 |
- QGLFormat::OpenGL_Version_4_3;
- }
- }
- return versionFlags;
-}
-
-/*!
- \enum QGLFormat::OpenGLVersionFlag
- \since 4.2
-
- This enum describes the various OpenGL versions that are
- recognized by Qt. Use the QGLFormat::openGLVersionFlags() function
- to identify which versions that are supported at runtime.
-
- \value OpenGL_Version_None If no OpenGL is present or if no OpenGL context is current.
-
- \value OpenGL_Version_1_1 OpenGL version 1.1 or higher is present.
-
- \value OpenGL_Version_1_2 OpenGL version 1.2 or higher is present.
-
- \value OpenGL_Version_1_3 OpenGL version 1.3 or higher is present.
-
- \value OpenGL_Version_1_4 OpenGL version 1.4 or higher is present.
-
- \value OpenGL_Version_1_5 OpenGL version 1.5 or higher is present.
-
- \value OpenGL_Version_2_0 OpenGL version 2.0 or higher is present.
- Note that version 2.0 supports all the functionality of version 1.5.
-
- \value OpenGL_Version_2_1 OpenGL version 2.1 or higher is present.
-
- \value OpenGL_Version_3_0 OpenGL version 3.0 or higher is present.
-
- \value OpenGL_Version_3_1 OpenGL version 3.1 or higher is present.
- Note that OpenGL version 3.1 or higher does not necessarily support all the features of
- version 3.0 and lower.
-
- \value OpenGL_Version_3_2 OpenGL version 3.2 or higher is present.
-
- \value OpenGL_Version_3_3 OpenGL version 3.3 or higher is present.
-
- \value OpenGL_Version_4_0 OpenGL version 4.0 or higher is present.
-
- \value OpenGL_Version_4_1 OpenGL version 4.1 or higher is present.
-
- \value OpenGL_Version_4_2 OpenGL version 4.2 or higher is present.
-
- \value OpenGL_Version_4_3 OpenGL version 4.3 or higher is present.
-
- \value OpenGL_ES_CommonLite_Version_1_0 OpenGL ES version 1.0 Common Lite or higher is present.
-
- \value OpenGL_ES_Common_Version_1_0 OpenGL ES version 1.0 Common or higher is present.
- The Common profile supports all the features of Common Lite.
-
- \value OpenGL_ES_CommonLite_Version_1_1 OpenGL ES version 1.1 Common Lite or higher is present.
-
- \value OpenGL_ES_Common_Version_1_1 OpenGL ES version 1.1 Common or higher is present.
- The Common profile supports all the features of Common Lite.
-
- \value OpenGL_ES_Version_2_0 OpenGL ES version 2.0 or higher is present.
- Note that OpenGL ES version 2.0 does not support all the features of OpenGL ES 1.x.
- So if OpenGL_ES_Version_2_0 is returned, none of the ES 1.x flags are returned.
-
- See also \l{http://www.opengl.org} for more information about the different
- revisions of OpenGL.
-
- \sa openGLVersionFlags()
-*/
-
-/*!
- \since 4.2
-
- Identifies, at runtime, which OpenGL versions that are supported
- by the current platform.
-
- Note that if OpenGL version 1.5 is supported, its predecessors
- (i.e., version 1.4 and lower) are also supported. To identify the
- support of a particular feature, like multi texturing, test for
- the version in which the feature was first introduced (i.e.,
- version 1.3 in the case of multi texturing) to adapt to the largest
- possible group of runtime platforms.
-
- This function needs a valid current OpenGL context to work;
- otherwise it will return OpenGL_Version_None.
-
- \sa hasOpenGL(), hasOpenGLOverlays()
-*/
-QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
-{
- static bool cachedDefault = false;
- static OpenGLVersionFlags defaultVersionFlags = OpenGL_Version_None;
- QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
- QGLTemporaryContext *tmpContext = 0;
-
- if (currentCtx && currentCtx->d_func()->version_flags_cached)
- return currentCtx->d_func()->version_flags;
-
- if (!currentCtx) {
- if (cachedDefault) {
- return defaultVersionFlags;
- } else {
- if (!hasOpenGL())
- return defaultVersionFlags;
- tmpContext = new QGLTemporaryContext;
- cachedDefault = true;
- }
- }
-
- QString versionString(QLatin1String(reinterpret_cast<const char*>(qgl_functions()->glGetString(GL_VERSION))));
- OpenGLVersionFlags versionFlags = qOpenGLVersionFlagsFromString(versionString);
- if (currentCtx) {
- currentCtx->d_func()->version_flags_cached = true;
- currentCtx->d_func()->version_flags = versionFlags;
- }
- if (tmpContext) {
- defaultVersionFlags = versionFlags;
- delete tmpContext;
- }
-
- return versionFlags;
-}
-
-
-/*!
- Returns the default QGLFormat for the application. All QGLWidget
- objects that are created use this format unless another format is
- specified, e.g. when they are constructed.
-
- If no special default format has been set using
- setDefaultFormat(), the default format is the same as that created
- with QGLFormat().
-
- \sa setDefaultFormat()
-*/
-
-QGLFormat QGLFormat::defaultFormat()
-{
- return *qgl_default_format();
-}
-
-/*!
- Sets a new default QGLFormat for the application to \a f. For
- example, to set single buffering as the default instead of double
- buffering, your main() might contain code like this:
- \snippet code/src_opengl_qgl.cpp 4
-
- \sa defaultFormat()
-*/
-
-void QGLFormat::setDefaultFormat(const QGLFormat &f)
-{
- *qgl_default_format() = f;
-}
-
-
-/*!
- Returns the default QGLFormat for overlay contexts.
-
- The default overlay format is:
- \list
- \li \l{setDoubleBuffer()}{Double buffer:} Disabled.
- \li \l{setDepth()}{Depth buffer:} Disabled.
- \li \l{setRgba()}{RGBA:} Disabled (i.e., color index enabled).
- \li \l{setAlpha()}{Alpha channel:} Disabled.
- \li \l{setAccum()}{Accumulator buffer:} Disabled.
- \li \l{setStencil()}{Stencil buffer:} Disabled.
- \li \l{setStereo()}{Stereo:} Disabled.
- \li \l{setDirectRendering()}{Direct rendering:} Enabled.
- \li \l{setOverlay()}{Overlay:} Disabled.
- \li \l{setSampleBuffers()}{Multisample buffers:} Disabled.
- \li \l{setPlane()}{Plane:} 1 (i.e., first overlay plane).
- \endlist
-
- \sa setDefaultFormat()
-*/
-
-QGLFormat QGLFormat::defaultOverlayFormat()
-{
- return *defaultOverlayFormatInstance();
-}
-
-/*!
- Sets a new default QGLFormat for overlay contexts to \a f. This
- format is used whenever a QGLWidget is created with a format that
- hasOverlay() enabled.
-
- For example, to get a double buffered overlay context (if
- available), use code like this:
-
- \snippet code/src_opengl_qgl.cpp 5
-
- As usual, you can find out after widget creation whether the
- underlying OpenGL system was able to provide the requested
- specification:
-
- \snippet code/src_opengl_qgl.cpp 6
-
- \sa defaultOverlayFormat()
-*/
-
-void QGLFormat::setDefaultOverlayFormat(const QGLFormat &f)
-{
- QGLFormat *defaultFormat = defaultOverlayFormatInstance();
- *defaultFormat = f;
- // Make sure the user doesn't request that the overlays themselves
- // have overlays, since it is unlikely that the system supports
- // infinitely many planes...
- defaultFormat->setOverlay(false);
-}
-
-
-/*!
- Returns \c true if all the options of the two QGLFormat objects
- \a a and \a b are equal; otherwise returns \c false.
-
- \relates QGLFormat
-*/
-
-bool operator==(const QGLFormat& a, const QGLFormat& b)
-{
- return (a.d == b.d) || ((int) a.d->opts == (int) b.d->opts
- && a.d->pln == b.d->pln
- && a.d->alphaSize == b.d->alphaSize
- && a.d->accumSize == b.d->accumSize
- && a.d->stencilSize == b.d->stencilSize
- && a.d->depthSize == b.d->depthSize
- && a.d->redSize == b.d->redSize
- && a.d->greenSize == b.d->greenSize
- && a.d->blueSize == b.d->blueSize
- && a.d->numSamples == b.d->numSamples
- && a.d->swapInterval == b.d->swapInterval
- && a.d->majorVersion == b.d->majorVersion
- && a.d->minorVersion == b.d->minorVersion
- && a.d->profile == b.d->profile);
-}
-
-#ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug dbg, const QGLFormat &f)
-{
- const QGLFormatPrivate * const d = f.d;
-
- QDebugStateSaver saver(dbg);
- dbg.nospace() << "QGLFormat("
- << "options " << d->opts
- << ", plane " << d->pln
- << ", depthBufferSize " << d->depthSize
- << ", accumBufferSize " << d->accumSize
- << ", stencilBufferSize " << d->stencilSize
- << ", redBufferSize " << d->redSize
- << ", greenBufferSize " << d->greenSize
- << ", blueBufferSize " << d->blueSize
- << ", alphaBufferSize " << d->alphaSize
- << ", samples " << d->numSamples
- << ", swapInterval " << d->swapInterval
- << ", majorVersion " << d->majorVersion
- << ", minorVersion " << d->minorVersion
- << ", profile " << d->profile
- << ')';
-
- return dbg;
-}
-#endif
-
-
-/*!
- Returns \c false if all the options of the two QGLFormat objects
- \a a and \a b are equal; otherwise returns \c true.
-
- \relates QGLFormat
-*/
-
-bool operator!=(const QGLFormat& a, const QGLFormat& b)
-{
- return !(a == b);
-}
-
-struct QGLContextGroupList {
- void append(QGLContextGroup *group) {
- QMutexLocker locker(&m_mutex);
- m_list.append(group);
- }
-
- void remove(QGLContextGroup *group) {
- QMutexLocker locker(&m_mutex);
- m_list.removeOne(group);
- }
-
- QList<QGLContextGroup *> m_list;
- QRecursiveMutex m_mutex;
-};
-
-Q_GLOBAL_STATIC(QGLContextGroupList, qt_context_groups)
-
-/*****************************************************************************
- QGLContext implementation
- *****************************************************************************/
-
-QGLContextGroup::QGLContextGroup(const QGLContext *context)
- : m_context(context), m_refs(1)
-{
- qt_context_groups()->append(this);
-}
-
-QGLContextGroup::~QGLContextGroup()
-{
- qt_context_groups()->remove(this);
-}
-
-const QGLContext *qt_gl_transfer_context(const QGLContext *ctx)
-{
- if (!ctx)
- return 0;
- QList<const QGLContext *> shares
- (QGLContextPrivate::contextGroup(ctx)->shares());
- if (shares.size() >= 2)
- return (ctx == shares.at(0)) ? shares.at(1) : shares.at(0);
- else
- return 0;
-}
-
-QGLContextPrivate::QGLContextPrivate(QGLContext *context)
- : internal_context(false)
- , q_ptr(context)
- , texture_destroyer(0)
- , functions(0)
-{
- group = new QGLContextGroup(context);
-
- texture_destroyer = new QGLTextureDestroyer;
-}
-
-QGLContextPrivate::~QGLContextPrivate()
-{
- delete functions;
-
- if (!group->m_refs.deref()) {
- Q_ASSERT(group->context() == q_ptr);
- delete group;
- }
-
- delete texture_destroyer;
-}
-
-void QGLContextPrivate::init(QPaintDevice *dev, const QGLFormat &format)
-{
- Q_Q(QGLContext);
- glFormat = reqFormat = format;
- valid = false;
- q->setDevice(dev);
-
- guiGlContext = 0;
- ownContext = false;
- fbo = 0;
- crWin = false;
- initDone = false;
- sharing = false;
- max_texture_size = -1;
- version_flags_cached = false;
- version_flags = QGLFormat::OpenGL_Version_None;
- current_fbo = 0;
- default_fbo = 0;
- active_engine = 0;
- workaround_needsFullClearOnEveryFrame = false;
- workaround_brokenFBOReadBack = false;
- workaround_brokenTexSubImage = false;
- workaroundsCached = false;
-
- workaround_brokenTextureFromPixmap = false;
- workaround_brokenTextureFromPixmap_init = false;
-
- workaround_brokenAlphaTexSubImage = false;
- workaround_brokenAlphaTexSubImage_init = false;
-
- for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i)
- vertexAttributeArraysEnabledState[i] = false;
-}
-
-QGLContext* QGLContext::currentCtx = 0;
-
-/*
- QGLTemporaryContext implementation
-*/
-class QGLTemporaryContextPrivate
-{
-public:
- QWindow *window;
- QOpenGLContext *context;
-
- QGLContext *oldContext;
-};
-
-QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)
- : d(new QGLTemporaryContextPrivate)
-{
- d->oldContext = const_cast<QGLContext *>(QGLContext::currentContext());
-
- d->window = new QWindow;
- d->window->setSurfaceType(QWindow::OpenGLSurface);
- d->window->setGeometry(QRect(0, 0, 3, 3));
- d->window->create();
-
- d->context = new QOpenGLContext;
-#if !defined(QT_OPENGL_ES)
- if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL) {
- // On desktop, request latest released version
- QSurfaceFormat format;
-#if defined(Q_OS_MAC)
- // OS X is limited to OpenGL 3.2 Core Profile at present
- // so set that here. If we use compatibility profile it
- // only reports 2.x contexts.
- format.setMajorVersion(3);
- format.setMinorVersion(2);
- format.setProfile(QSurfaceFormat::CoreProfile);
-#else
- format.setMajorVersion(4);
- format.setMinorVersion(3);
-#endif
- d->context->setFormat(format);
- }
-#endif // QT_OPENGL_ES
- d->context->create();
- d->context->makeCurrent(d->window);
-}
-
-QGLTemporaryContext::~QGLTemporaryContext()
-{
- if (d->oldContext)
- d->oldContext->makeCurrent();
-
- delete d->context;
- delete d->window;
-}
-
-/*
- Read back the contents of the currently bound framebuffer, used in
- QGLWidget::grabFrameBuffer(), QGLPixelbuffer::toImage() and
- QGLFramebufferObject::toImage()
-*/
-
-static void convertFromGLImage(QImage &img, int w, int h, bool alpha_format, bool include_alpha)
-{
- Q_ASSERT(!img.isNull());
- if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
- // OpenGL gives RGBA; Qt wants ARGB
- uint *p = (uint*)img.bits();
- uint *end = p + w*h;
- if (alpha_format && include_alpha) {
- while (p < end) {
- uint a = *p << 24;
- *p = (*p >> 8) | a;
- p++;
- }
- } else {
- // This is an old legacy fix for PowerPC based Macs, which
- // we shouldn't remove
- while (p < end) {
- *p = 0xff000000 | (*p>>8);
- ++p;
- }
- }
- } else {
- // OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
- for (int y = 0; y < h; y++) {
- uint *q = (uint*)img.scanLine(y);
- for (int x=0; x < w; ++x) {
- const uint pixel = *q;
- if (alpha_format && include_alpha) {
- *q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff)
- | (pixel & 0xff00ff00);
- } else {
- *q = 0xff000000 | ((pixel << 16) & 0xff0000)
- | ((pixel >> 16) & 0xff) | (pixel & 0x00ff00);
- }
-
- q++;
- }
- }
-
- }
- img = img.mirrored();
-}
-
-QImage qt_gl_read_frame_buffer(const QSize &size, bool alpha_format, bool include_alpha)
-{
- QImage img(size, (alpha_format && include_alpha) ? QImage::Format_ARGB32_Premultiplied
- : QImage::Format_RGB32);
- if (img.isNull())
- return QImage();
- int w = size.width();
- int h = size.height();
- qgl_functions()->glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
- convertFromGLImage(img, w, h, alpha_format, include_alpha);
- return img;
-}
-
-QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha)
-{
- QImage img(size, alpha_format ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
- if (img.isNull())
- return QImage();
- int w = size.width();
- int h = size.height();
-#ifndef QT_OPENGL_ES
- if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-
- qgl1_functions()->glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
- }
-#endif // QT_OPENGL_ES
- convertFromGLImage(img, w, h, alpha_format, include_alpha);
- return img;
-}
-
-Q_GLOBAL_STATIC(QGLTextureCache, qt_gl_texture_cache)
-
-QGLTextureCache::QGLTextureCache()
- : m_cache(64*1024) // cache ~64 MB worth of textures - this is not accurate though
-{
- QImagePixmapCleanupHooks::instance()->addPlatformPixmapModificationHook(cleanupTexturesForPixampData);
- QImagePixmapCleanupHooks::instance()->addPlatformPixmapDestructionHook(cleanupBeforePixmapDestruction);
- QImagePixmapCleanupHooks::instance()->addImageHook(cleanupTexturesForCacheKey);
-}
-
-QGLTextureCache::~QGLTextureCache()
-{
- QImagePixmapCleanupHooks::instance()->removePlatformPixmapModificationHook(cleanupTexturesForPixampData);
- QImagePixmapCleanupHooks::instance()->removePlatformPixmapDestructionHook(cleanupBeforePixmapDestruction);
- QImagePixmapCleanupHooks::instance()->removeImageHook(cleanupTexturesForCacheKey);
-}
-
-void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
-{
- QWriteLocker locker(&m_lock);
- const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
- const bool inserted = m_cache.insert(cacheKey, texture, cost);
- Q_UNUSED(inserted) Q_ASSERT(inserted);
-}
-
-void QGLTextureCache::remove(qint64 key)
-{
- QWriteLocker locker(&m_lock);
- QMutexLocker groupLocker(&qt_context_groups()->m_mutex);
- QList<QGLContextGroup *>::const_iterator it = qt_context_groups()->m_list.constBegin();
- while (it != qt_context_groups()->m_list.constEnd()) {
- const QGLTextureCacheKey cacheKey = {key, *it};
- m_cache.remove(cacheKey);
- ++it;
- }
-}
-
-bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
-{
- QWriteLocker locker(&m_lock);
- QList<QGLTextureCacheKey> keys = m_cache.keys();
- for (int i = 0; i < keys.size(); ++i) {
- QGLTexture *tex = m_cache.object(keys.at(i));
- if (tex->id == textureId && tex->context == ctx) {
- tex->options |= QGLContext::MemoryManagedBindOption; // forces a glDeleteTextures() call
- m_cache.remove(keys.at(i));
- return true;
- }
- }
- return false;
-}
-
-void QGLTextureCache::removeContextTextures(QGLContext* ctx)
-{
- QWriteLocker locker(&m_lock);
- QList<QGLTextureCacheKey> keys = m_cache.keys();
- for (int i = 0; i < keys.size(); ++i) {
- const QGLTextureCacheKey &key = keys.at(i);
- if (m_cache.object(key)->context == ctx)
- m_cache.remove(key);
- }
-}
-
-/*
- a hook that removes textures from the cache when a pixmap/image
- is deref'ed
-*/
-void QGLTextureCache::cleanupTexturesForCacheKey(qint64 cacheKey)
-{
- qt_gl_texture_cache()->remove(cacheKey);
-}
-
-
-void QGLTextureCache::cleanupTexturesForPixampData(QPlatformPixmap* pmd)
-{
- cleanupTexturesForCacheKey(pmd->cacheKey());
-}
-
-void QGLTextureCache::cleanupBeforePixmapDestruction(QPlatformPixmap* pmd)
-{
- // Remove any bound textures first:
- cleanupTexturesForPixampData(pmd);
-}
-
-QGLTextureCache *QGLTextureCache::instance()
-{
- return qt_gl_texture_cache();
-}
-
-// DDS format structure
-struct DDSFormat {
- quint32 dwSize;
- quint32 dwFlags;
- quint32 dwHeight;
- quint32 dwWidth;
- quint32 dwLinearSize;
- quint32 dummy1;
- quint32 dwMipMapCount;
- quint32 dummy2[11];
- struct {
- quint32 dummy3[2];
- quint32 dwFourCC;
- quint32 dummy4[5];
- } ddsPixelFormat;
-};
-
-// compressed texture pixel formats
-#define FOURCC_DXT1 0x31545844
-#define FOURCC_DXT2 0x32545844
-#define FOURCC_DXT3 0x33545844
-#define FOURCC_DXT4 0x34545844
-#define FOURCC_DXT5 0x35545844
-
-// ####TODO Properly #ifdef this class to use #define symbols actually defined
-// by system GL includes
-#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
-#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
-#endif
-
-#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
-#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
-#endif
-
-#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
-#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
-#endif
-
-#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
-#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
-#endif
-
-#ifndef GL_GENERATE_MIPMAP_SGIS
-#define GL_GENERATE_MIPMAP_SGIS 0x8191
-#define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192
-#endif
-
-/*!
- \class QGLContext
- \inmodule QtOpenGL
- \obsolete
-
- \brief The QGLContext class encapsulates an OpenGL rendering context.
-
- An OpenGL rendering context is a complete set of OpenGL state
- variables. The rendering context's \l {QGL::FormatOption} {format}
- is set in the constructor, but it can also be set later with
- setFormat(). The format options that are actually set are returned
- by format(); the options you asked for are returned by
- requestedFormat(). Note that after a QGLContext object has been
- constructed, the actual OpenGL context must be created by
- explicitly calling the \l{create()}
- function. The makeCurrent() function makes this context the
- current rendering context. You can make \e no context current
- using doneCurrent(). The reset() function will reset the context
- and make it invalid.
-
- You can examine properties of the context with, e.g. isValid(),
- isSharing(), initialized(), windowCreated() and
- overlayTransparentColor().
-
- If you're using double buffering you can swap the screen contents
- with the off-screen buffer using swapBuffers().
-
- Please note that QGLContext is not thread safe.
-*/
-
-/*!
- \enum QGLContext::BindOption
- \since 4.6
-
- A set of options to decide how to bind a texture using bindTexture().
-
- \value NoBindOption Don't do anything, pass the texture straight
- through.
-
- \value InvertedYBindOption Specifies that the texture should be flipped
- over the X axis so that the texture coordinate 0,0 corresponds to
- the top left corner. Inverting the texture implies a deep copy
- prior to upload.
-
- \value MipmapBindOption Specifies that bindTexture() should try
- to generate mipmaps. If the GL implementation supports the \c
- GL_SGIS_generate_mipmap extension, mipmaps will be automatically
- generated for the texture. Mipmap generation is only supported for
- the \c GL_TEXTURE_2D target.
-
- \value PremultipliedAlphaBindOption Specifies that the image should be
- uploaded with premultiplied alpha and does a conversion accordingly.
-
- \value LinearFilteringBindOption Specifies that the texture filtering
- should be set to GL_LINEAR. Default is GL_NEAREST. If mipmap is
- also enabled, filtering will be set to GL_LINEAR_MIPMAP_LINEAR.
-
- \value DefaultBindOption In Qt 4.5 and earlier, bindTexture()
- would mirror the image and automatically generate mipmaps. This
- option helps preserve this default behavior.
-
- \omitvalue CanFlipNativePixmapBindOption \omit Used by x11 from pixmap to choose
- whether or not it can bind the pixmap upside down or not. \endomit
-
- \omitvalue MemoryManagedBindOption \omit Used by paint engines to
- indicate that the pixmap should be memory managed along side with
- the pixmap/image that it stems from, e.g. installing destruction
- hooks in them. \endomit
-
- \omitvalue TemporarilyCachedBindOption \omit Used by paint engines on some
- platforms to indicate that the pixmap or image texture is possibly
- cached only temporarily and must be destroyed immediately after the use. \endomit
-
- \omitvalue InternalBindOption
-*/
-
-/*!
- \obsolete
-
- Constructs an OpenGL context for the given paint \a device, which
- can be a widget or a pixmap. The \a format specifies several
- display options for the context.
-
- If the underlying OpenGL/Window system cannot satisfy all the
- features requested in \a format, the nearest subset of features
- will be used. After creation, the format() method will return the
- actual format obtained.
-
- Note that after a QGLContext object has been constructed, \l
- create() must be called explicitly to create the actual OpenGL
- context. The context will be \l {isValid()}{invalid} if it was not
- possible to obtain a GL context at all.
-*/
-
-QGLContext::QGLContext(const QGLFormat &format, QPaintDevice *device)
- : d_ptr(new QGLContextPrivate(this))
-{
- Q_D(QGLContext);
- d->init(device, format);
-}
-
-/*!
- Constructs an OpenGL context with the given \a format which
- specifies several display options for the context.
-
- If the underlying OpenGL/Window system cannot satisfy all the
- features requested in \a format, the nearest subset of features
- will be used. After creation, the format() method will return the
- actual format obtained.
-
- Note that after a QGLContext object has been constructed, \l
- create() must be called explicitly to create the actual OpenGL
- context. The context will be \l {isValid()}{invalid} if it was not
- possible to obtain a GL context at all.
-
- \sa format(), isValid()
-*/
-QGLContext::QGLContext(const QGLFormat &format)
- : d_ptr(new QGLContextPrivate(this))
-{
- Q_D(QGLContext);
- d->init(0, format);
-}
-
-static void qDeleteQGLContext(void *handle)
-{
- QGLContext *context = static_cast<QGLContext *>(handle);
- delete context;
-}
-
-QGLContext::QGLContext(QOpenGLContext *context)
- : d_ptr(new QGLContextPrivate(this))
-{
- Q_D(QGLContext);
- d->init(0, QGLFormat::fromSurfaceFormat(context->format()));
- d->guiGlContext = context;
- d->guiGlContext->setQGLContextHandle(this, qDeleteQGLContext);
- d->ownContext = false;
- d->valid = context->isValid();
- d->setupSharing();
-}
-
-/*!
- Returns the OpenGL context handle.
-*/
-QOpenGLContext *QGLContext::contextHandle() const
-{
- Q_D(const QGLContext);
- return d->guiGlContext;
-}
-
-/*!
- Returns an OpenGL context for the window context specified by the \a context
- parameter.
-*/
-QGLContext *QGLContext::fromOpenGLContext(QOpenGLContext *context)
-{
- if (!context)
- return 0;
- if (context->qGLContextHandle()) {
- return reinterpret_cast<QGLContext *>(context->qGLContextHandle());
- }
- QGLContext *glContext = new QGLContext(context);
- //Don't call create on context. This can cause the platformFormat to be set on the widget, which
- //will cause the platformWindow to be recreated.
- return glContext;
-}
-
-/*!
- Destroys the OpenGL context and frees its resources.
-*/
-
-QGLContext::~QGLContext()
-{
- // remove any textures cached in this context
- QGLTextureCache::instance()->removeContextTextures(this);
-
- // clean up resources specific to this context
- d_ptr->cleanup();
-
- QGLSignalProxy::instance()->emitAboutToDestroyContext(this);
- reset();
-}
-
-void QGLContextPrivate::cleanup()
-{
-}
-
-#define ctx q_ptr
-void QGLContextPrivate::setVertexAttribArrayEnabled(int arrayIndex, bool enabled)
-{
- Q_Q(QGLContext);
- Q_ASSERT(arrayIndex < QT_GL_VERTEX_ARRAY_TRACKED_COUNT);
-#ifdef glEnableVertexAttribArray
- Q_ASSERT(glEnableVertexAttribArray);
-#endif
-
- if (vertexAttributeArraysEnabledState[arrayIndex] && !enabled)
- q->functions()->glDisableVertexAttribArray(arrayIndex);
-
- if (!vertexAttributeArraysEnabledState[arrayIndex] && enabled)
- q->functions()->glEnableVertexAttribArray(arrayIndex);
-
- vertexAttributeArraysEnabledState[arrayIndex] = enabled;
-}
-
-void QGLContextPrivate::syncGlState()
-{
- Q_Q(QGLContext);
-#ifdef glEnableVertexAttribArray
- Q_ASSERT(glEnableVertexAttribArray);
-#endif
- for (int i = 0; i < QT_GL_VERTEX_ARRAY_TRACKED_COUNT; ++i) {
- if (vertexAttributeArraysEnabledState[i])
- q->functions()->glEnableVertexAttribArray(i);
- else
- q->functions()->glDisableVertexAttribArray(i);
- }
-
-}
-#undef ctx
-
-void QGLContextPrivate::swapRegion(const QRegion &)
-{
- Q_Q(QGLContext);
- q->swapBuffers();
-}
-
-/*!
- \overload
-
- Reads the compressed texture file \a fileName and generates a 2D GL
- texture from it.
-
- This function can load DirectDrawSurface (DDS) textures in the
- DXT1, DXT3 and DXT5 DDS formats if the \c GL_ARB_texture_compression
- and \c GL_EXT_texture_compression_s3tc extensions are supported.
-
- Since 4.6.1, textures in the ETC1 format can be loaded if the
- \c GL_OES_compressed_ETC1_RGB8_texture extension is supported
- and the ETC1 texture has been encapsulated in the PVR container format.
- Also, textures in the PVRTC2 and PVRTC4 formats can be loaded
- if the \c GL_IMG_texture_compression_pvrtc extension is supported.
-
- \sa deleteTexture()
-*/
-
-GLuint QGLContext::bindTexture(const QString &fileName)
-{
- QGLTexture texture(this);
- QSize size = texture.bindCompressedTexture(fileName);
- if (!size.isValid())
- return 0;
- return texture.id;
-}
-
-static inline QRgb qt_gl_convertToGLFormatHelper(QRgb src_pixel, GLenum texture_format)
-{
- if (texture_format == GL_BGRA) {
- if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
- return ((src_pixel << 24) & 0xff000000)
- | ((src_pixel >> 24) & 0x000000ff)
- | ((src_pixel << 8) & 0x00ff0000)
- | ((src_pixel >> 8) & 0x0000ff00);
- } else {
- return src_pixel;
- }
- } else { // GL_RGBA
- if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
- return (src_pixel << 8) | ((src_pixel >> 24) & 0xff);
- } else {
- return ((src_pixel << 16) & 0xff0000)
- | ((src_pixel >> 16) & 0xff)
- | (src_pixel & 0xff00ff00);
- }
- }
-}
-
-static void convertToGLFormatHelper(QImage &dst, const QImage &img, GLenum texture_format)
-{
- Q_ASSERT(dst.depth() == 32);
- Q_ASSERT(img.depth() == 32);
-
- if (dst.size() != img.size()) {
- int target_width = dst.width();
- int target_height = dst.height();
- qreal sx = target_width / qreal(img.width());
- qreal sy = target_height / qreal(img.height());
-
- quint32 *dest = (quint32 *) dst.scanLine(0); // NB! avoid detach here
- const uchar *srcPixels = img.constScanLine(img.height() - 1);
- int sbpl = img.bytesPerLine();
- int dbpl = dst.bytesPerLine();
-
- int ix = int(0x00010000 / sx);
- int iy = int(0x00010000 / sy);
-
- quint32 basex = int(0.5 * ix);
- quint32 srcy = int(0.5 * iy);
-
- // scale, swizzle and mirror in one loop
- while (target_height--) {
- const uint *src = (const quint32 *) (srcPixels - (srcy >> 16) * sbpl);
- int srcx = basex;
- for (int x=0; x<target_width; ++x) {
- dest[x] = qt_gl_convertToGLFormatHelper(src[srcx >> 16], texture_format);
- srcx += ix;
- }
- dest = (quint32 *)(((uchar *) dest) + dbpl);
- srcy += iy;
- }
- } else {
- const int width = img.width();
- const int height = img.height();
- const uint *p = (const uint*) img.scanLine(img.height() - 1);
- uint *q = (uint*) dst.scanLine(0);
-
- if (texture_format == GL_BGRA) {
- if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
- // mirror + swizzle
- for (int i=0; i < height; ++i) {
- const uint *end = p + width;
- while (p < end) {
- *q = ((*p << 24) & 0xff000000)
- | ((*p >> 24) & 0x000000ff)
- | ((*p << 8) & 0x00ff0000)
- | ((*p >> 8) & 0x0000ff00);
- p++;
- q++;
- }
- p -= 2 * width;
- }
- } else {
- const uint bytesPerLine = img.bytesPerLine();
- for (int i=0; i < height; ++i) {
- memcpy(q, p, bytesPerLine);
- q += width;
- p -= width;
- }
- }
- } else {
- if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
- for (int i=0; i < height; ++i) {
- const uint *end = p + width;
- while (p < end) {
- *q = (*p << 8) | ((*p >> 24) & 0xff);
- p++;
- q++;
- }
- p -= 2 * width;
- }
- } else {
- for (int i=0; i < height; ++i) {
- const uint *end = p + width;
- while (p < end) {
- *q = ((*p << 16) & 0xff0000) | ((*p >> 16) & 0xff) | (*p & 0xff00ff00);
- p++;
- q++;
- }
- p -= 2 * width;
- }
- }
- }
- }
-}
-
-/*! \internal */
-QGLTexture *QGLContextPrivate::bindTexture(const QImage &image, GLenum target, GLint format,
- QGLContext::BindOptions options)
-{
- Q_Q(QGLContext);
-
- const qint64 key = image.cacheKey();
- QGLTexture *texture = textureCacheLookup(key, target);
- if (texture) {
- if (image.paintingActive()) {
- // A QPainter is active on the image - take the safe route and replace the texture.
- q->deleteTexture(texture->id);
- texture = 0;
- } else {
- qgl_functions()->glBindTexture(target, texture->id);
- return texture;
- }
- }
-
- if (!texture)
- texture = bindTexture(image, target, format, key, options);
- // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
- Q_ASSERT(texture);
-
- // Enable the cleanup hooks for this image so that the texture cache entry is removed when the
- // image gets deleted:
- QImagePixmapCleanupHooks::enableCleanupHooks(image);
-
- return texture;
-}
-
-// #define QGL_BIND_TEXTURE_DEBUG
-
-// ####TODO Properly #ifdef this file to use #define symbols actually defined
-// by OpenGL/ES includes
-#ifndef GL_UNSIGNED_INT_8_8_8_8_REV
-#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
-#endif
-
-// map from Qt's ARGB endianness-dependent format to GL's big-endian RGBA layout
-static inline void qgl_byteSwapImage(QImage &img, GLenum pixel_type)
-{
- const int width = img.width();
- const int height = img.height();
-
- if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV
- || (pixel_type == GL_UNSIGNED_BYTE && QSysInfo::ByteOrder == QSysInfo::LittleEndian))
- {
- for (int i = 0; i < height; ++i) {
- uint *p = (uint *) img.scanLine(i);
- for (int x = 0; x < width; ++x)
- p[x] = ((p[x] << 16) & 0xff0000) | ((p[x] >> 16) & 0xff) | (p[x] & 0xff00ff00);
- }
- } else {
- for (int i = 0; i < height; ++i) {
- uint *p = (uint *) img.scanLine(i);
- for (int x = 0; x < width; ++x)
- p[x] = (p[x] << 8) | ((p[x] >> 24) & 0xff);
- }
- }
-}
-
-QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, GLint internalFormat,
- const qint64 key, QGLContext::BindOptions options)
-{
- Q_Q(QGLContext);
- QOpenGLFunctions *funcs = qgl_functions();
-
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x, key=%llx\n",
- image.width(), image.height(), internalFormat, int(options), key);
- QTime time;
- time.start();
-#endif
-
-#ifndef QT_NO_DEBUG
- // Reset the gl error stack...git
- while (funcs->glGetError() != GL_NO_ERROR) ;
-#endif
-
- // Scale the pixmap if needed. GL textures needs to have the
- // dimensions 2^n+2(border) x 2^m+2(border), unless we're using GL
- // 2.0 or use the GL_TEXTURE_RECTANGLE texture target
- int tx_w = qNextPowerOfTwo(image.width() - 1);
- int tx_h = qNextPowerOfTwo(image.height() - 1);
-
- QImage img = image;
-
- if (!qgl_extensions()->hasOpenGLFeature(QOpenGLFunctions::NPOTTextures)
- && !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0)
- && (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
- {
- img = img.scaled(tx_w, tx_h);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - upscaled to %dx%d (%d ms)\n", tx_w, tx_h, time.elapsed());
-
-#endif
- }
-
- GLuint filtering = options & QGLContext::LinearFilteringBindOption ? GL_LINEAR : GL_NEAREST;
-
- GLuint tx_id;
- funcs->glGenTextures(1, &tx_id);
- funcs->glBindTexture(target, tx_id);
- funcs->glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filtering);
-
- QOpenGLContext *ctx = QOpenGLContext::currentContext();
- bool genMipmap = !ctx->isOpenGLES();
- if (glFormat.directRendering()
- && (qgl_extensions()->hasOpenGLExtension(QOpenGLExtensions::GenerateMipmap))
- && target == GL_TEXTURE_2D
- && (options & QGLContext::MipmapBindOption))
- {
-#if !defined(QT_OPENGL_ES_2)
- if (genMipmap) {
- funcs->glHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST);
- funcs->glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
- } else {
- funcs->glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
- genMipmap = true;
- }
-#else
- funcs->glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
- genMipmap = true;
-#endif
- funcs->glTexParameteri(target, GL_TEXTURE_MIN_FILTER, options & QGLContext::LinearFilteringBindOption
- ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - generating mipmaps (%d ms)\n", time.elapsed());
-#endif
- } else {
- funcs->glTexParameteri(target, GL_TEXTURE_MIN_FILTER, filtering);
- }
-
- QImage::Format target_format = img.format();
- bool premul = options & QGLContext::PremultipliedAlphaBindOption;
- bool needsbyteswap = true;
- GLenum externalFormat;
- GLuint pixel_type;
- if (target_format == QImage::Format_RGBA8888
- || target_format == QImage::Format_RGBA8888_Premultiplied
- || target_format == QImage::Format_RGBX8888) {
- externalFormat = GL_RGBA;
- pixel_type = GL_UNSIGNED_BYTE;
- needsbyteswap = false;
- } else if (qgl_extensions()->hasOpenGLExtension(QOpenGLExtensions::BGRATextureFormat)) {
- externalFormat = GL_BGRA;
- needsbyteswap = false;
- if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2)
- pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
- else
- pixel_type = GL_UNSIGNED_BYTE;
- } else {
- externalFormat = GL_RGBA;
- pixel_type = GL_UNSIGNED_BYTE;
- }
-
- switch (target_format) {
- case QImage::Format_ARGB32:
- if (premul) {
- img = img.convertToFormat(target_format = QImage::Format_ARGB32_Premultiplied);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted ARGB32 -> ARGB32_Premultiplied (%d ms) \n", time.elapsed());
-#endif
- }
- break;
- case QImage::Format_ARGB32_Premultiplied:
- if (!premul) {
- img = img.convertToFormat(target_format = QImage::Format_ARGB32);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted ARGB32_Premultiplied -> ARGB32 (%d ms)\n", time.elapsed());
-#endif
- }
- break;
- case QImage::Format_RGBA8888:
- if (premul) {
- img = img.convertToFormat(target_format = QImage::Format_RGBA8888_Premultiplied);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted RGBA8888 -> RGBA8888_Premultiplied (%d ms) \n", time.elapsed());
-#endif
- }
- break;
- case QImage::Format_RGBA8888_Premultiplied:
- if (!premul) {
- img = img.convertToFormat(target_format = QImage::Format_RGBA8888);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted RGBA8888_Premultiplied -> RGBA8888 (%d ms) \n", time.elapsed());
-#endif
- }
- break;
- case QImage::Format_RGB16:
- pixel_type = GL_UNSIGNED_SHORT_5_6_5;
- externalFormat = GL_RGB;
- internalFormat = GL_RGB;
- needsbyteswap = false;
- break;
- case QImage::Format_RGB32:
- case QImage::Format_RGBX8888:
- break;
- default:
- // Ideally more formats would be converted directly to an RGBA8888 format,
- // but we are only guaranteed to have a fast conversion to an ARGB format.
- if (img.hasAlphaChannel()) {
- img = img.convertToFormat(premul
- ? QImage::Format_ARGB32_Premultiplied
- : QImage::Format_ARGB32);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted to 32-bit alpha format (%d ms)\n", time.elapsed());
-#endif
- } else {
- img = img.convertToFormat(QImage::Format_RGB32);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - converted to 32-bit (%d ms)\n", time.elapsed());
-#endif
- }
- }
-
- if (options & QGLContext::InvertedYBindOption) {
- if (img.isDetached()) {
- int ipl = img.bytesPerLine() / 4;
- int h = img.height();
- for (int y=0; y<h/2; ++y) {
- int *a = (int *) img.scanLine(y);
- int *b = (int *) img.scanLine(h - y - 1);
- for (int x=0; x<ipl; ++x)
- qSwap(a[x], b[x]);
- }
- } else {
- // Create a new image and copy across. If we use the
- // above in-place code then a full copy of the image is
- // made before the lines are swapped, which processes the
- // data twice. This version should only do it once.
- img = img.mirrored();
- }
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - flipped bits over y (%d ms)\n", time.elapsed());
-#endif
- }
-
- if (needsbyteswap) {
- // The only case where we end up with a depth different from
- // 32 in the switch above is for the RGB16 case, where we do
- // not need a byteswap.
- Q_ASSERT(img.depth() == 32);
- qgl_byteSwapImage(img, pixel_type);
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - did byte swapping (%d ms)\n", time.elapsed());
-#endif
- }
- if (ctx->isOpenGLES()) {
- // OpenGL/ES requires that the internal and external formats be
- // identical.
- internalFormat = externalFormat;
- }
-#ifdef QGL_BIND_TEXTURE_DEBUG
- printf(" - uploading, image.format=%d, externalFormat=0x%x, internalFormat=0x%x, pixel_type=0x%x\n",
- img.format(), externalFormat, internalFormat, pixel_type);
-#endif
-
- const QImage &constRef = img; // to avoid detach in bits()...
- funcs->glTexImage2D(target, 0, internalFormat, img.width(), img.height(), 0, externalFormat,
- pixel_type, constRef.bits());
- if (genMipmap && ctx->isOpenGLES())
- q->functions()->glGenerateMipmap(target);
-#ifndef QT_NO_DEBUG
- GLenum error = funcs->glGetError();
- if (error != GL_NO_ERROR) {
- qWarning(" - texture upload failed, error code 0x%x, enum: %d (%x)\n", error, target, target);
- }
-#endif
-
-#ifdef QGL_BIND_TEXTURE_DEBUG
- static int totalUploadTime = 0;
- totalUploadTime += time.elapsed();
- printf(" - upload done in %d ms, (accumulated: %d ms)\n", time.elapsed(), totalUploadTime);
-#endif
-
-
- // this assumes the size of a texture is always smaller than the max cache size
- int cost = img.width()*img.height()*4/1024;
- QGLTexture *texture = new QGLTexture(q, tx_id, target, options);
- QGLTextureCache::instance()->insert(q, key, texture, cost);
-
- return texture;
-}
-
-QGLTexture *QGLContextPrivate::textureCacheLookup(const qint64 key, GLenum target)
-{
- Q_Q(QGLContext);
- QGLTexture *texture = QGLTextureCache::instance()->getTexture(q, key);
- if (texture && texture->target == target
- && (texture->context == q || QGLContext::areSharing(q, texture->context)))
- {
- return texture;
- }
- return 0;
-}
-
-/*! \internal */
-QGLTexture *QGLContextPrivate::bindTexture(const QPixmap &pixmap, GLenum target, GLint format, QGLContext::BindOptions options)
-{
- Q_Q(QGLContext);
- QPlatformPixmap *pd = pixmap.handle();
- Q_UNUSED(pd);
-
- const qint64 key = pixmap.cacheKey();
- QGLTexture *texture = textureCacheLookup(key, target);
- if (texture) {
- if (pixmap.paintingActive()) {
- // A QPainter is active on the pixmap - take the safe route and replace the texture.
- q->deleteTexture(texture->id);
- texture = 0;
- } else {
- qgl_functions()->glBindTexture(target, texture->id);
- return texture;
- }
- }
-
- if (!texture) {
- QImage image;
- QPaintEngine* paintEngine = pixmap.paintEngine();
- if (!paintEngine || paintEngine->type() != QPaintEngine::Raster)
- image = pixmap.toImage();
- else {
- // QRasterPixmapData::toImage() will deep-copy the backing QImage if there's an active QPainter on it.
- // For performance reasons, we don't want that here, so we temporarily redirect the paint engine.
- QPaintDevice* currentPaintDevice = paintEngine->paintDevice();
- paintEngine->setPaintDevice(0);
- image = pixmap.toImage();
- paintEngine->setPaintDevice(currentPaintDevice);
- }
-
- // If the system depth is 16 and the pixmap doesn't have an alpha channel
- // then we convert it to RGB16 in the hope that it gets uploaded as a 16
- // bit texture which is much faster to access than a 32-bit one.
- if (pixmap.depth() == 16 && !image.hasAlphaChannel() )
- image = image.convertToFormat(QImage::Format_RGB16);
- texture = bindTexture(image, target, format, key, options);
- }
- // NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
- Q_ASSERT(texture);
-
- if (texture->id > 0)
- QImagePixmapCleanupHooks::enableCleanupHooks(pixmap);
-
- return texture;
-}
-
-/*! \internal */
-int QGLContextPrivate::maxTextureSize()
-{
- if (max_texture_size != -1)
- return max_texture_size;
-
- QOpenGLFunctions *funcs = qgl_functions();
- funcs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
-
-#ifndef QT_OPENGL_ES
- Q_Q(QGLContext);
- if (!q->contextHandle()->isOpenGLES()) {
- GLenum proxy = GL_PROXY_TEXTURE_2D;
-
- GLint size;
- GLint next = 64;
- funcs->glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
- gl1funcs->glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &size);
- if (size == 0) {
- return max_texture_size;
- }
- do {
- size = next;
- next = size * 2;
-
- if (next > max_texture_size)
- break;
- funcs->glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
- gl1funcs->glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &next);
- } while (next > size);
-
- max_texture_size = size;
- }
-#endif
-
- return max_texture_size;
-}
-
-/*!
- Returns a QGLFunctions object that is initialized for this context.
- */
-QGLFunctions *QGLContext::functions() const
-{
- QGLContextPrivate *d = const_cast<QGLContextPrivate *>(d_func());
- if (!d->functions) {
- d->functions = new QGLFunctions(this);
- d->functions->initializeGLFunctions(this);
- }
- return d->functions;
-}
-
-/*!
- Generates and binds a 2D GL texture to the current context, based
- on \a image. The generated texture id is returned and can be used in
- later \c glBindTexture() calls.
-
- \overload
-*/
-GLuint QGLContext::bindTexture(const QImage &image, GLenum target, GLint format)
-{
- if (image.isNull())
- return 0;
-
- Q_D(QGLContext);
- QGLTexture *texture = d->bindTexture(image, target, format, DefaultBindOption);
- return texture->id;
-}
-
-/*!
- \since 4.6
-
- Generates and binds a 2D GL texture to the current context, based
- on \a image. The generated texture id is returned and can be used
- in later \c glBindTexture() calls.
-
- The \a target parameter specifies the texture target. The default
- target is \c GL_TEXTURE_2D.
-
- The \a format parameter sets the internal format for the
- texture. The default format is \c GL_RGBA.
-
- The binding \a options are a set of options used to decide how to
- bind the texture to the context.
-
- The texture that is generated is cached, so multiple calls to
- bindTexture() with the same QImage will return the same texture
- id.
-
- Note that we assume default values for the glPixelStore() and
- glPixelTransfer() parameters.
-
- \sa deleteTexture()
-*/
-GLuint QGLContext::bindTexture(const QImage &image, GLenum target, GLint format, BindOptions options)
-{
- if (image.isNull())
- return 0;
-
- Q_D(QGLContext);
- QGLTexture *texture = d->bindTexture(image, target, format, options);
- return texture->id;
-}
-
-/*! \overload
-
- Generates and binds a 2D GL texture based on \a pixmap.
-*/
-GLuint QGLContext::bindTexture(const QPixmap &pixmap, GLenum target, GLint format)
-{
- if (pixmap.isNull())
- return 0;
-
- Q_D(QGLContext);
- QGLTexture *texture = d->bindTexture(pixmap, target, format, DefaultBindOption);
- return texture->id;
-}
-
-/*!
- \overload
- \since 4.6
-
- Generates and binds a 2D GL texture to the current context, based
- on \a pixmap.
-*/
-GLuint QGLContext::bindTexture(const QPixmap &pixmap, GLenum target, GLint format, BindOptions options)
-{
- if (pixmap.isNull())
- return 0;
-
- Q_D(QGLContext);
- QGLTexture *texture = d->bindTexture(pixmap, target, format, options);
- return texture->id;
-}
-
-/*!
- Removes the texture identified by \a id from the texture cache,
- and calls glDeleteTextures() to delete the texture from the
- context.
-
- \sa bindTexture()
-*/
-void QGLContext::deleteTexture(GLuint id)
-{
- if (QGLTextureCache::instance()->remove(this, id))
- return;
- qgl_functions()->glDeleteTextures(1, &id);
-}
-
-void qt_add_rect_to_array(const QRectF &r, GLfloat *array)
-{
- qreal left = r.left();
- qreal right = r.right();
- qreal top = r.top();
- qreal bottom = r.bottom();
-
- array[0] = left;
- array[1] = top;
- array[2] = right;
- array[3] = top;
- array[4] = right;
- array[5] = bottom;
- array[6] = left;
- array[7] = bottom;
-}
-
-void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, GLfloat *array)
-{
- array[0] = x1;
- array[1] = y1;
- array[2] = x2;
- array[3] = y1;
- array[4] = x2;
- array[5] = y2;
- array[6] = x1;
- array[7] = y2;
-}
-
-#if !defined(QT_OPENGL_ES_2)
-
-static void qDrawTextureRect(const QRectF &target, GLint textureWidth, GLint textureHeight, GLenum textureTarget)
-{
- QOpenGLFunctions *funcs = qgl_functions();
- GLfloat tx = 1.0f;
- GLfloat ty = 1.0f;
-
-#ifdef QT_OPENGL_ES
- Q_UNUSED(textureWidth);
- Q_UNUSED(textureHeight);
- Q_UNUSED(textureTarget);
-#else
- if (textureTarget != GL_TEXTURE_2D && !QOpenGLContext::currentContext()->isOpenGLES()) {
- if (textureWidth == -1 || textureHeight == -1) {
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
- gl1funcs->glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
- gl1funcs->glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
- }
-
- tx = GLfloat(textureWidth);
- ty = GLfloat(textureHeight);
- }
-#endif
-
- GLfloat texCoordArray[4*2] = {
- 0, ty, tx, ty, tx, 0, 0, 0
- };
-
- GLfloat vertexArray[4*2];
- qt_add_rect_to_array(target, vertexArray);
-
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
- gl1funcs->glVertexPointer(2, GL_FLOAT, 0, vertexArray);
- gl1funcs->glTexCoordPointer(2, GL_FLOAT, 0, texCoordArray);
-
- gl1funcs->glEnableClientState(GL_VERTEX_ARRAY);
- gl1funcs->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- funcs->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
- gl1funcs->glDisableClientState(GL_VERTEX_ARRAY);
- gl1funcs->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-}
-
-#endif // !QT_OPENGL_ES_2
-
-/*!
- \since 4.4
-
- This function supports the following use cases:
-
- \list
- \li On OpenGL and OpenGL ES 1.x it draws the given texture, \a textureId,
- to the given target rectangle, \a target, in OpenGL model space. The
- \a textureTarget should be a 2D texture target.
- \li On OpenGL and OpenGL ES 2.x, if a painter is active, not inside a
- beginNativePainting / endNativePainting block, and uses the
- engine with type QPaintEngine::OpenGL2, the function will draw the given
- texture, \a textureId, to the given target rectangle, \a target,
- respecting the current painter state. This will let you draw a texture
- with the clip, transform, render hints, and composition mode set by the
- painter. Note that the texture target needs to be GL_TEXTURE_2D for this
- use case, and that this is the only supported use case under OpenGL ES 2.x.
- \endlist
-
-*/
-void QGLContext::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
-{
-#if !defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
- if (d_ptr->active_engine &&
- d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
- QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
- if (!eng->isNativePaintingActive()) {
- QRectF src(0, 0, target.width(), target.height());
- QSize size(target.width(), target.height());
- if (eng->drawTexture(target, textureId, size, src))
- return;
- }
- }
-#endif
-
-#ifndef QT_OPENGL_ES_2
- QOpenGLFunctions *funcs = qgl_functions();
- if (!contextHandle()->isOpenGLES()) {
-#ifdef QT_OPENGL_ES
- if (textureTarget != GL_TEXTURE_2D) {
- qWarning("QGLContext::drawTexture(): texture target must be GL_TEXTURE_2D on OpenGL ES");
- return;
- }
-#else
- const bool wasEnabled = funcs->glIsEnabled(GL_TEXTURE_2D);
- GLint oldTexture;
- funcs->glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
-#endif
-
- funcs->glEnable(textureTarget);
- funcs->glBindTexture(textureTarget, textureId);
-
- qDrawTextureRect(target, -1, -1, textureTarget);
-
-#ifdef QT_OPENGL_ES
- funcs->glDisable(textureTarget);
-#else
- if (!wasEnabled)
- funcs->glDisable(textureTarget);
- funcs->glBindTexture(textureTarget, oldTexture);
-#endif
- return;
- }
-#else
- Q_UNUSED(target);
- Q_UNUSED(textureId);
- Q_UNUSED(textureTarget);
-#endif
- qWarning("drawTexture() with OpenGL ES 2.0 requires an active OpenGL2 paint engine");
-}
-
-/*!
- \since 4.4
-
- This function supports the following use cases:
-
- \list
- \li By default it draws the given texture, \a textureId,
- at the given \a point in OpenGL model space. The
- \a textureTarget should be a 2D texture target.
- \li If a painter is active, not inside a
- beginNativePainting / endNativePainting block, and uses the
- engine with type QPaintEngine::OpenGL2, the function will draw the given
- texture, \a textureId, at the given \a point,
- respecting the current painter state. This will let you draw a texture
- with the clip, transform, render hints, and composition mode set by the
- painter. Note that the texture target needs to be GL_TEXTURE_2D for this
- use case.
- \endlist
-
- \note This function is not supported under any version of OpenGL ES.
-*/
-void QGLContext::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
-{
-#ifdef QT_OPENGL_ES
- Q_UNUSED(point);
- Q_UNUSED(textureId);
- Q_UNUSED(textureTarget);
-#else
- if (!contextHandle()->isOpenGLES()) {
- QOpenGLFunctions *funcs = qgl_functions();
- const bool wasEnabled = funcs->glIsEnabled(GL_TEXTURE_2D);
- GLint oldTexture;
- funcs->glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
-
- funcs->glEnable(textureTarget);
- funcs->glBindTexture(textureTarget, textureId);
-
- GLint textureWidth;
- GLint textureHeight;
-
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
- gl1funcs->glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
- gl1funcs->glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
-
- if (d_ptr->active_engine &&
- d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
- QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
- if (!eng->isNativePaintingActive()) {
- QRectF dest(point, QSizeF(textureWidth, textureHeight));
- QRectF src(0, 0, textureWidth, textureHeight);
- QSize size(textureWidth, textureHeight);
- if (eng->drawTexture(dest, textureId, size, src))
- return;
- }
- }
-
- qDrawTextureRect(QRectF(point, QSizeF(textureWidth, textureHeight)), textureWidth, textureHeight, textureTarget);
-
- if (!wasEnabled)
- funcs->glDisable(textureTarget);
- funcs->glBindTexture(textureTarget, oldTexture);
- return;
- }
-#endif
- qWarning("drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES, use rect version instead");
-}
-
-/*!
- This function sets the limit for the texture cache to \a size,
- expressed in kilobytes.
-
- By default, the cache limit is approximately 64 MB.
-
- \sa textureCacheLimit()
-*/
-void QGLContext::setTextureCacheLimit(int size)
-{
- QGLTextureCache::instance()->setMaxCost(size);
-}
-
-/*!
- Returns the current texture cache limit in kilobytes.
-
- \sa setTextureCacheLimit()
-*/
-int QGLContext::textureCacheLimit()
-{
- return QGLTextureCache::instance()->maxCost();
-}
-
-
-/*!
- \fn QGLFormat QGLContext::format() const
-
- Returns the frame buffer format that was obtained (this may be a
- subset of what was requested).
-
- \sa requestedFormat()
-*/
-
-/*!
- \fn QGLFormat QGLContext::requestedFormat() const
-
- Returns the frame buffer format that was originally requested in
- the constructor or setFormat().
-
- \sa format()
-*/
-
-/*!
- Sets a \a format for this context. The context is \l{reset()}{reset}.
-
- Call create() to create a new GL context that tries to match the
- new format.
-
- \snippet code/src_opengl_qgl.cpp 7
-
- \sa format(), reset(), create()
-*/
-
-void QGLContext::setFormat(const QGLFormat &format)
-{
- Q_D(QGLContext);
- reset();
- d->glFormat = d->reqFormat = format;
-}
-
-/*!
- \internal
-*/
-void QGLContext::setDevice(QPaintDevice *pDev)
-{
- Q_D(QGLContext);
- // Do not touch the valid flag here. The context is either a new one and
- // valid is not yet set or it is adapted from a valid QOpenGLContext in which
- // case it must remain valid.
- d->paintDevice = pDev;
- if (d->paintDevice && (d->paintDevice->devType() != QInternal::Widget
- && d->paintDevice->devType() != QInternal::Pixmap
- && d->paintDevice->devType() != QInternal::Pbuffer)) {
- qWarning("QGLContext: Unsupported paint device type");
- }
-}
-
-/*!
- \fn bool QGLContext::isValid() const
-
- Returns \c true if a GL rendering context has been successfully
- created; otherwise returns \c false.
-*/
-
-/*!
- \fn void QGLContext::setValid(bool valid)
- \internal
-
- Forces the GL rendering context to be valid.
-*/
-
-/*!
- \fn bool QGLContext::isSharing() const
-
- Returns \c true if this context is sharing its GL context with
- another QGLContext, otherwise false is returned. Note that context
- sharing might not be supported between contexts with different
- formats.
-*/
-
-/*!
- Returns \c true if \a context1 and \a context2 are sharing their
- GL resources such as textures, shader programs, etc;
- otherwise returns \c false.
-
- \since 4.6
-*/
-bool QGLContext::areSharing(const QGLContext *context1, const QGLContext *context2)
-{
- if (!context1 || !context2)
- return false;
- return context1->d_ptr->group == context2->d_ptr->group;
-}
-
-/*!
- \fn bool QGLContext::deviceIsPixmap() const
-
- Returns \c true if the paint device of this context is a pixmap;
- otherwise returns \c false.
-
- Since Qt 5 the paint device is never actually a pixmap. renderPixmap() is
- however still simulated using framebuffer objects and readbacks, and this
- function will return \c true in this case.
-*/
-
-/*!
- \fn bool QGLContext::windowCreated() const
-
- Returns \c true if a window has been created for this context;
- otherwise returns \c false.
-
- \sa setWindowCreated()
-*/
-
-/*!
- \fn void QGLContext::setWindowCreated(bool on)
-
- If \a on is true the context has had a window created for it. If
- \a on is false no window has been created for the context.
-
- \sa windowCreated()
-*/
-
-/*!
- \fn uint QGLContext::colorIndex(const QColor& c) const
-
- \internal
-
- Returns a colormap index for the color c, in ColorIndex mode. Used
- by qglColor() and qglClearColor().
-*/
-uint QGLContext::colorIndex(const QColor&) const
-{
- return 0;
-}
-
-/*!
- \fn bool QGLContext::initialized() const
-
- Returns \c true if this context has been initialized, i.e. if
- QGLWidget::initializeGL() has been performed on it; otherwise
- returns \c false.
-
- \sa setInitialized()
-*/
-
-/*!
- \fn void QGLContext::setInitialized(bool on)
-
- If \a on is true the context has been initialized, i.e.
- QGLContext::setInitialized() has been called on it. If \a on is
- false the context has not been initialized.
-
- \sa initialized()
-*/
-
-/*!
- \fn const QGLContext* QGLContext::currentContext()
-
- Returns the current context, i.e. the context to which any OpenGL
- commands will currently be directed. Returns 0 if no context is
- current.
-
- \sa makeCurrent()
-*/
-
-/*!
- \fn QColor QGLContext::overlayTransparentColor() const
-
- If this context is a valid context in an overlay plane, returns
- the plane's transparent color. Otherwise returns an \l{QColor::isValid()}{invalid} color.
-
- The returned color's \l{QColormap::pixel()}{pixel} value is
- the index of the transparent color in the colormap of the overlay
- plane. (Naturally, the color's RGB values are meaningless.)
-
- The returned QColor object will generally work as expected only
- when passed as the argument to QGLWidget::qglColor() or
- QGLWidget::qglClearColor(). Under certain circumstances it can
- also be used to draw transparent graphics with a QPainter.
-*/
-QColor QGLContext::overlayTransparentColor() const
-{
- return QColor(); // Invalid color
-}
-
-/*!
- Creates the GL context. Returns \c true if it was successful in
- creating a valid GL rendering context on the paint device
- specified in the constructor; otherwise returns \c false (i.e. the
- context is invalid).
-
- If the OpenGL implementation on your system does not support the requested
- version of OpenGL context, then QGLContext will try to create the closest
- matching version. The actual created context properties can be queried
- using the QGLFormat returned by the format() function. For example, if
- you request a context that supports OpenGL 4.3 Core profile but the driver
- and/or hardware only supports version 3.2 Core profile contexts then you will
- get a 3.2 Core profile context.
-
- After successful creation, format() returns the set of features of
- the created GL rendering context.
-
- If \a shareContext points to a valid QGLContext, this method will
- try to establish OpenGL display list and texture object sharing
- between this context and the \a shareContext. Note that this may
- fail if the two contexts have different \l {format()} {formats}.
- Use isSharing() to see if sharing is in effect.
-
- \warning Implementation note: initialization of C++ class
- members usually takes place in the class constructor. QGLContext
- is an exception because it must be simple to customize. The
- virtual functions chooseContext() (and chooseVisual() for X11) can
- be reimplemented in a subclass to select a particular context. The
- problem is that virtual functions are not properly called during
- construction (even though this is correct C++) because C++
- constructs class hierarchies from the bottom up. For this reason
- we need a create() function.
-
- \sa chooseContext(), format(), isValid()
-*/
-
-bool QGLContext::create(const QGLContext* shareContext)
-{
- Q_D(QGLContext);
- if (!d->paintDevice && !d->guiGlContext)
- return false;
-
- reset();
- d->valid = chooseContext(shareContext);
- if (d->valid && d->paintDevice && d->paintDevice->devType() == QInternal::Widget) {
- QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
- wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
- }
- return d->valid;
-}
-
-bool QGLContext::isValid() const
-{
- Q_D(const QGLContext);
- return d->valid;
-}
-
-void QGLContext::setValid(bool valid)
-{
- Q_D(QGLContext);
- d->valid = valid;
-}
-
-bool QGLContext::isSharing() const
-{
- Q_D(const QGLContext);
- return d->group->isSharing();
-}
-
-QGLFormat QGLContext::format() const
-{
- Q_D(const QGLContext);
- return d->glFormat;
-}
-
-QGLFormat QGLContext::requestedFormat() const
-{
- Q_D(const QGLContext);
- return d->reqFormat;
-}
-
- QPaintDevice* QGLContext::device() const
-{
- Q_D(const QGLContext);
- return d->paintDevice;
-}
-
-bool QGLContext::deviceIsPixmap() const
-{
- Q_D(const QGLContext);
- return !d->readback_target_size.isEmpty();
-}
-
-
-bool QGLContext::windowCreated() const
-{
- Q_D(const QGLContext);
- return d->crWin;
-}
-
-
-void QGLContext::setWindowCreated(bool on)
-{
- Q_D(QGLContext);
- d->crWin = on;
-}
-
-bool QGLContext::initialized() const
-{
- Q_D(const QGLContext);
- return d->initDone;
-}
-
-void QGLContext::setInitialized(bool on)
-{
- Q_D(QGLContext);
- d->initDone = on;
-}
-
-const QGLContext* QGLContext::currentContext()
-{
- if (const QOpenGLContext *threadContext = QOpenGLContext::currentContext()) {
- return QGLContext::fromOpenGLContext(const_cast<QOpenGLContext *>(threadContext));
- }
- return 0;
-}
-
-void QGLContextPrivate::setCurrentContext(QGLContext *context)
-{
- Q_UNUSED(context);
-}
-
-/*!
- Moves the QGLContext to the given \a thread.
-
- Enables calling swapBuffers() and makeCurrent() on the context in
- the given thread.
-*/
-void QGLContext::moveToThread(QThread *thread)
-{
- Q_D(QGLContext);
- if (d->guiGlContext)
- d->guiGlContext->moveToThread(thread);
-}
-
-/*!
- \fn bool QGLContext::chooseContext(const QGLContext* shareContext = 0)
-
- This semi-internal function is called by create(). It creates a
- system-dependent OpenGL handle that matches the format() of \a
- shareContext as closely as possible, returning true if successful
- or false if a suitable handle could not be found.
-
- On Windows, it calls the virtual function choosePixelFormat(),
- which finds a matching pixel format identifier. On X11, it calls
- the virtual function chooseVisual() which finds an appropriate X
- visual. On other platforms it may work differently.
-*/
-bool QGLContext::chooseContext(const QGLContext* shareContext)
-{
- Q_D(QGLContext);
- if(!d->paintDevice || d->paintDevice->devType() != QInternal::Widget) {
- // Unlike in Qt 4, the only possible target is a widget backed by an OpenGL-based
- // QWindow. Pixmaps in particular are not supported anymore as paint devices since
- // starting from Qt 5 QPixmap is raster-backed on almost all platforms.
- d->valid = false;
- }else {
- QWidget *widget = static_cast<QWidget *>(d->paintDevice);
- QGLFormat glformat = format();
- QSurfaceFormat winFormat = QGLFormat::toSurfaceFormat(glformat);
- if (widget->testAttribute(Qt::WA_TranslucentBackground))
- winFormat.setAlphaBufferSize(qMax(winFormat.alphaBufferSize(), 8));
-
- QWindow *window = widget->windowHandle();
- if (!window->handle()
- || window->surfaceType() != QWindow::OpenGLSurface
- || window->requestedFormat() != winFormat)
- {
- window->setSurfaceType(QWindow::OpenGLSurface);
- window->setFormat(winFormat);
- window->destroy();
- window->create();
- }
-
- if (d->ownContext)
- delete d->guiGlContext;
- d->ownContext = true;
- QOpenGLContext *shareGlContext = shareContext ? shareContext->d_func()->guiGlContext : 0;
- d->guiGlContext = new QOpenGLContext;
- d->guiGlContext->setFormat(winFormat);
- d->guiGlContext->setShareContext(shareGlContext);
- d->valid = d->guiGlContext->create();
-
- if (d->valid)
- d->guiGlContext->setQGLContextHandle(this, 0);
-
- d->glFormat = QGLFormat::fromSurfaceFormat(d->guiGlContext->format());
- d->setupSharing();
- }
-
-
- return d->valid;
-}
-
-/*!
- \fn void QGLContext::reset()
-
- Resets the context and makes it invalid.
-
- \sa create(), isValid()
-*/
-void QGLContext::reset()
-{
- Q_D(QGLContext);
- if (!d->valid)
- return;
- d->cleanup();
-
- d->crWin = false;
- d->sharing = false;
- d->valid = false;
- d->transpColor = QColor();
- d->initDone = false;
- QGLContextGroup::removeShare(this);
- if (d->guiGlContext) {
- if (QOpenGLContext::currentContext() == d->guiGlContext)
- doneCurrent();
- if (d->ownContext) {
- if (d->guiGlContext->thread() == QThread::currentThread())
- delete d->guiGlContext;
- else
- d->guiGlContext->deleteLater();
- } else
- d->guiGlContext->setQGLContextHandle(0,0);
- d->guiGlContext = 0;
- }
- d->ownContext = false;
-}
-
-/*!
- \fn void QGLContext::makeCurrent()
-
- Makes this context the current OpenGL rendering context. All GL
- functions you call operate on this context until another context
- is made current.
-
- In some very rare cases the underlying call may fail. If this
- occurs an error message is output to stderr.
-
- If you call this from a thread other than the main UI thread,
- make sure you've first pushed the context to the relevant thread
- from the UI thread using moveToThread().
-*/
-void QGLContext::makeCurrent()
-{
- Q_D(QGLContext);
- if (!d->paintDevice || d->paintDevice->devType() != QInternal::Widget)
- return;
-
- QWidget *widget = static_cast<QWidget *>(d->paintDevice);
- if (!widget->windowHandle())
- return;
-
- if (d->guiGlContext->makeCurrent(widget->windowHandle())) {
- if (!d->workaroundsCached) {
- d->workaroundsCached = true;
- const char *renderer = reinterpret_cast<const char *>(d->guiGlContext->functions()->glGetString(GL_RENDERER));
- if (renderer && strstr(renderer, "Mali")) {
- d->workaround_brokenFBOReadBack = true;
- }
- }
- }
-}
-
-/*!
- \fn void QGLContext::swapBuffers() const
-
- Call this to finish a frame of OpenGL rendering, and make sure to
- call makeCurrent() again before issuing any further OpenGL commands,
- for example as part of a new frame.
-*/
-void QGLContext::swapBuffers() const
-{
- Q_D(const QGLContext);
- if (!d->paintDevice || d->paintDevice->devType() != QInternal::Widget)
- return;
-
- QWidget *widget = static_cast<QWidget *>(d->paintDevice);
- if (!widget->windowHandle())
- return;
-
- d->guiGlContext->swapBuffers(widget->windowHandle());
-}
-
-/*!
- \fn void QGLContext::doneCurrent()
-
- Makes no GL context the current context. Normally, you do not need
- to call this function; QGLContext calls it as necessary.
-*/
-void QGLContext::doneCurrent()
-{
- Q_D(QGLContext);
- d->guiGlContext->doneCurrent();
-}
-
-/*!
- \fn QPaintDevice* QGLContext::device() const
-
- Returns the paint device set for this context.
-
- \sa QGLContext::QGLContext()
-*/
-
-/*****************************************************************************
- QGLWidget implementation
- *****************************************************************************/
-
-
-/*!
- \class QGLWidget
- \inmodule QtOpenGL
- \obsolete
-
- \brief The QGLWidget class is a widget for rendering OpenGL graphics.
-
- QGLWidget provides functionality for displaying OpenGL graphics
- integrated into a Qt application. It is very simple to use. You
- inherit from it and use the subclass like any other QWidget,
- except that you have the choice between using QPainter and
- standard OpenGL rendering commands.
-
- \note This class is part of the legacy \l {Qt OpenGL} module and,
- like the other \c QGL classes, should be avoided in the new
- applications. Instead, starting from Qt 5.4, prefer using
- QOpenGLWidget and the \c QOpenGL classes.
-
- QGLWidget provides three convenient virtual functions that you can
- reimplement in your subclass to perform the typical OpenGL tasks:
-
- \list
- \li paintGL() - Renders the OpenGL scene. Gets called whenever the widget
- needs to be updated.
- \li resizeGL() - Sets up the OpenGL viewport, projection, etc. Gets
- called whenever the widget has been resized (and also when it
- is shown for the first time because all newly created widgets get a
- resize event automatically).
- \li initializeGL() - Sets up the OpenGL rendering context, defines display
- lists, etc. Gets called once before the first time resizeGL() or
- paintGL() is called.
- \endlist
-
- Here is a rough outline of how a QGLWidget subclass might look:
-
- \snippet code/src_opengl_qgl.cpp 8
-
- If you need to trigger a repaint from places other than paintGL()
- (a typical example is when using \l{QTimer}{timers} to
- animate scenes), you should call the widget's updateGL() function.
-
- Your widget's OpenGL rendering context is made current when
- paintGL(), resizeGL(), or initializeGL() is called. If you need to
- call the standard OpenGL API functions from other places (e.g. in
- your widget's constructor or in your own paint functions), you
- must call makeCurrent() first.
-
- QGLWidget provides functions for requesting a new display
- \l{QGLFormat}{format} and you can also create widgets with
- customized rendering \l{QGLContext}{contexts}.
-
- You can also share OpenGL display lists between QGLWidget objects (see
- the documentation of the QGLWidget constructors for details).
-
- Note that under Windows, the QGLContext belonging to a QGLWidget
- has to be recreated when the QGLWidget is reparented. This is
- necessary due to limitations on the Windows platform. This will
- most likely cause problems for users that have subclassed and
- installed their own QGLContext on a QGLWidget. It is possible to
- work around this issue by putting the QGLWidget inside a dummy
- widget and then reparenting the dummy widget, instead of the
- QGLWidget. This will side-step the issue altogether, and is what
- we recommend for users that need this kind of functionality.
-
- On \macos, when Qt is built with Cocoa support, a QGLWidget
- can't have any sibling widgets placed ontop of itself. This is due
- to limitations in the Cocoa API and is not supported by Apple.
-
- \section1 Overlays
-
- The QGLWidget creates a GL overlay context in addition to the
- normal context if overlays are supported by the underlying system.
-
- If you want to use overlays, you specify it in the
- \l{QGLFormat}{format}. (Note: Overlay must be requested in the format
- passed to the QGLWidget constructor.) Your GL widget should also
- implement some or all of these virtual methods:
-
- \list
- \li paintOverlayGL()
- \li resizeOverlayGL()
- \li initializeOverlayGL()
- \endlist
-
- These methods work in the same way as the normal paintGL() etc.
- functions, except that they will be called when the overlay
- context is made current. You can explicitly make the overlay
- context current by using makeOverlayCurrent(), and you can access
- the overlay context directly (e.g. to ask for its transparent
- color) by calling overlayContext().
-
- On X servers in which the default visual is in an overlay plane,
- non-GL Qt windows can also be used for overlays.
-
- \section1 Painting Techniques
-
- As described above, subclass QGLWidget to render pure 3D content in the
- following way:
-
- \list
- \li Reimplement the QGLWidget::initializeGL() and QGLWidget::resizeGL() to
- set up the OpenGL state and provide a perspective transformation.
- \li Reimplement QGLWidget::paintGL() to paint the 3D scene, calling only
- OpenGL functions to draw on the widget.
- \endlist
-
- It is also possible to draw 2D graphics onto a QGLWidget subclass, it is necessary
- to reimplement QGLWidget::paintEvent() and do the following:
-
- \list
- \li Construct a QPainter object.
- \li Initialize it for use on the widget with the QPainter::begin() function.
- \li Draw primitives using QPainter's member functions.
- \li Call QPainter::end() to finish painting.
- \endlist
-
- \section1 Threading
-
- As of Qt version 4.8, support for doing threaded GL rendering has
- been improved. There are three scenarios that we currently support:
- \list
- \li 1. Buffer swapping in a thread.
-
- Swapping buffers in a double buffered context may be a
- synchronous, locking call that may be a costly operation in some
- GL implementations. Especially so on embedded devices. It's not
- optimal to have the CPU idling while the GPU is doing a buffer
- swap. In those cases it is possible to do the rendering in the
- main thread and do the actual buffer swap in a separate
- thread. This can be done with the following steps:
-
- 1. Call doneCurrent() in the main thread when the rendering is
- finished.
-
- 2. Call QGLContext::moveToThread(swapThread) to transfer ownership
- of the context to the swapping thread.
-
- 3. Notify the swapping thread that it can grab the context.
-
- 4. Make the rendering context current in the swapping thread with
- makeCurrent() and then call swapBuffers().
-
- 5. Call doneCurrent() in the swapping thread.
-
- 6. Call QGLContext::moveToThread(qApp->thread()) and notify the
- main thread that swapping is done.
-
- Doing this will free up the main thread so that it can continue
- with, for example, handling UI events or network requests. Even if
- there is a context swap involved, it may be preferable compared to
- having the main thread wait while the GPU finishes the swap
- operation. Note that this is highly implementation dependent.
-
- \li 2. Texture uploading in a thread.
-
- Doing texture uploads in a thread may be very useful for
- applications handling large amounts of images that needs to be
- displayed, like for instance a photo gallery application. This is
- supported in Qt through the existing bindTexture() API. A simple
- way of doing this is to create two sharing QGLWidgets. One is made
- current in the main GUI thread, while the other is made current in
- the texture upload thread. The widget in the uploading thread is
- never shown, it is only used for sharing textures with the main
- thread. For each texture that is bound via bindTexture(), notify
- the main thread so that it can start using the texture.
-
- \li 3. Using QPainter to draw into a QGLWidget in a thread.
-
- In Qt 4.8, it is possible to draw into a QGLWidget using a
- QPainter in a separate thread. Note that this is also possible for
- QGLPixelBuffers and QGLFramebufferObjects. Since this is only
- supported in the GL 2 paint engine, OpenGL 2.0 or OpenGL ES 2.0 is
- required.
-
- QGLWidgets can only be created in the main GUI thread. This means
- a call to doneCurrent() is necessary to release the GL context
- from the main thread, before the widget can be drawn into by
- another thread. You then need to call QGLContext::moveToThread()
- to transfer ownership of the context to the thread in which you
- want to make it current.
- Also, the main GUI thread will dispatch resize and
- paint events to a QGLWidget when the widget is resized, or parts
- of it becomes exposed or needs redrawing. It is therefore
- necessary to handle those events because the default
- implementations inside QGLWidget will try to make the QGLWidget's
- context current, which again will interfere with any threads
- rendering into the widget. Reimplement QGLWidget::paintEvent() and
- QGLWidget::resizeEvent() to notify the rendering thread that a
- resize or update is necessary, and be careful not to call the base
- class implementation. If you are rendering an animation, it might
- not be necessary to handle the paint event at all since the
- rendering thread is doing regular updates. Then it would be enough
- to reimplement QGLWidget::paintEvent() to do nothing.
-
- \endlist
-
- As a general rule when doing threaded rendering: be aware that
- binding and releasing contexts in different threads have to be
- synchronized by the user. A GL rendering context can only be
- current in one thread at any time. If you try to open a QPainter
- on a QGLWidget and the widget's rendering context is current in
- another thread, it will fail.
-
- In addition to this, rendering using raw GL calls in a separate
- thread is supported.
-
- \e{OpenGL is a trademark of Silicon Graphics, Inc. in the United States and other
- countries.}
-
- \sa QOpenGLWidget, QGLPixelBuffer
-*/
-
-/*!
- Constructs an OpenGL widget with a \a parent widget.
-
- The \l{QGLFormat::defaultFormat()}{default format} is
- used. The widget will be \l{isValid()}{invalid} if the
- system has no \l{QGLFormat::hasOpenGL()}{OpenGL support}.
-
- The \a parent and widget flag, \a f, arguments are passed
- to the QWidget constructor.
-
- If \a shareWidget is a valid QGLWidget, this widget will share
- OpenGL display lists and texture objects with \a shareWidget. But
- if \a shareWidget and this widget have different \l {format()}
- {formats}, sharing might not be possible. You can check whether
- sharing is in effect by calling isSharing().
-
- The initialization of OpenGL rendering state, etc. should be done
- by overriding the initializeGL() function, rather than in the
- constructor of your QGLWidget subclass.
-
- \sa QGLFormat::defaultFormat(), {Textures Example}
-*/
-
-QGLWidget::QGLWidget(QWidget *parent, const QGLWidget* shareWidget, Qt::WindowFlags f)
- : QWidget(*(new QGLWidgetPrivate), parent, f)
-{
- Q_D(QGLWidget);
- d->init(new QGLContext(QGLFormat::defaultFormat(), this), shareWidget);
-}
-
-/*!
- \internal
- */
-QGLWidget::QGLWidget(QGLWidgetPrivate &dd, const QGLFormat &format, QWidget *parent, const QGLWidget *shareWidget, Qt::WindowFlags f)
- : QWidget(dd, parent, f)
-{
- Q_D(QGLWidget);
- d->init(new QGLContext(format, this), shareWidget);
-
-}
-
-
-/*!
- Constructs an OpenGL widget with parent \a parent.
-
- The \a format argument specifies the desired
- \l{QGLFormat}{rendering options}.
- If the underlying OpenGL/Window system
- cannot satisfy all the features requested in \a format, the
- nearest subset of features will be used. After creation, the
- format() method will return the actual format obtained.
-
- The widget will be \l{isValid()}{invalid} if the system
- has no \l{QGLFormat::hasOpenGL()}{OpenGL support}.
-
- The \a parent and widget flag, \a f, arguments are passed
- to the QWidget constructor.
-
- If \a shareWidget is a valid QGLWidget, this widget will share
- OpenGL display lists and texture objects with \a shareWidget. But
- if \a shareWidget and this widget have different \l {format()}
- {formats}, sharing might not be possible. You can check whether
- sharing is in effect by calling isSharing().
-
- The initialization of OpenGL rendering state, etc. should be done
- by overriding the initializeGL() function, rather than in the
- constructor of your QGLWidget subclass.
-
- \sa QGLFormat::defaultFormat(), isValid()
-*/
-
-QGLWidget::QGLWidget(const QGLFormat &format, QWidget *parent, const QGLWidget* shareWidget,
- Qt::WindowFlags f)
- : QWidget(*(new QGLWidgetPrivate), parent, f)
-{
- Q_D(QGLWidget);
- d->init(new QGLContext(format, this), shareWidget);
-}
-
-/*!
- Constructs an OpenGL widget with parent \a parent.
-
- The \a context argument is a pointer to the QGLContext that
- you wish to be bound to this widget. This allows you to pass in
- your own QGLContext sub-classes.
-
- The widget will be \l{isValid()}{invalid} if the system
- has no \l{QGLFormat::hasOpenGL()}{OpenGL support}.
-
- The \a parent and widget flag, \a f, arguments are passed
- to the QWidget constructor.
-
- If \a shareWidget is a valid QGLWidget, this widget will share
- OpenGL display lists and texture objects with \a shareWidget. But
- if \a shareWidget and this widget have different \l {format()}
- {formats}, sharing might not be possible. You can check whether
- sharing is in effect by calling isSharing().
-
- The initialization of OpenGL rendering state, etc. should be done
- by overriding the initializeGL() function, rather than in the
- constructor of your QGLWidget subclass.
-
- \sa QGLFormat::defaultFormat(), isValid()
-*/
-QGLWidget::QGLWidget(QGLContext *context, QWidget *parent, const QGLWidget *shareWidget,
- Qt::WindowFlags f)
- : QWidget(*(new QGLWidgetPrivate), parent, f)
-{
- Q_D(QGLWidget);
- d->init(context, shareWidget);
-}
-
-/*!
- Destroys the widget.
-*/
-
-QGLWidget::~QGLWidget()
-{
- Q_D(QGLWidget);
- delete d->glcx;
- d->glcx = 0;
- d->cleanupColormaps();
-}
-
-/*!
- \fn QGLFormat QGLWidget::format() const
-
- Returns the format of the contained GL rendering context.
-*/
-
-/*!
- \fn bool QGLWidget::doubleBuffer() const
-
- Returns \c true if the contained GL rendering context has double
- buffering; otherwise returns \c false.
-
- \sa QGLFormat::doubleBuffer()
-*/
-
-/*!
- \fn void QGLWidget::setAutoBufferSwap(bool on)
-
- If \a on is true automatic GL buffer swapping is switched on;
- otherwise it is switched off.
-
- If \a on is true and the widget is using a double-buffered format,
- the background and foreground GL buffers will automatically be
- swapped after each paintGL() call.
-
- The buffer auto-swapping is on by default.
-
- \sa autoBufferSwap(), doubleBuffer(), swapBuffers()
-*/
-
-/*!
- \fn bool QGLWidget::autoBufferSwap() const
-
- Returns \c true if the widget is doing automatic GL buffer swapping;
- otherwise returns \c false.
-
- \sa setAutoBufferSwap()
-*/
-
-/*!
- \fn QFunctionPointer QGLContext::getProcAddress(const QString &proc) const
-
- Returns a function pointer to the GL extension function passed in
- \a proc. \nullptr is returned if a pointer to the function could not be
- obtained.
-*/
-QFunctionPointer QGLContext::getProcAddress(const QString &procName) const
-{
- Q_D(const QGLContext);
- return d->guiGlContext->getProcAddress(procName.toLatin1());
-}
-
-/*!
- \fn bool QGLWidget::isValid() const
-
- Returns \c true if the widget has a valid GL rendering context;
- otherwise returns \c false. A widget will be invalid if the system
- has no \l{QGLFormat::hasOpenGL()}{OpenGL support}.
-*/
-
-bool QGLWidget::isValid() const
-{
- Q_D(const QGLWidget);
- return d->glcx && d->glcx->isValid();
-}
-
-/*!
- \fn bool QGLWidget::isSharing() const
-
- Returns \c true if this widget's GL context is shared with another GL
- context, otherwise false is returned. Context sharing might not be
- possible if the widgets use different formats.
-
- \sa format()
-*/
-
-bool QGLWidget::isSharing() const
-{
- Q_D(const QGLWidget);
- return d->glcx->isSharing();
-}
-
-/*!
- \fn void QGLWidget::makeCurrent()
-
- Makes this widget the current widget for OpenGL operations, i.e.
- makes the widget's rendering context the current OpenGL rendering
- context.
-*/
-
-void QGLWidget::makeCurrent()
-{
- Q_D(QGLWidget);
- d->makeCurrent();
-}
-
-bool QGLWidgetPrivate::makeCurrent()
-{
- glcx->makeCurrent();
- return QGLContext::currentContext() == glcx;
-}
-
-/*!
- \fn void QGLWidget::doneCurrent()
-
- Makes no GL context the current context. Normally, you do not need
- to call this function; QGLContext calls it as necessary. However,
- it may be useful in multithreaded environments.
-*/
-
-void QGLWidget::doneCurrent()
-{
- Q_D(QGLWidget);
- d->glcx->doneCurrent();
-}
-
-/*!
- \fn void QGLWidget::swapBuffers()
-
- Swaps the screen contents with an off-screen buffer. This only
- works if the widget's format specifies double buffer mode.
-
- Normally, there is no need to explicitly call this function
- because it is done automatically after each widget repaint, i.e.
- each time after paintGL() has been executed.
-
- \sa doubleBuffer(), setAutoBufferSwap(), QGLFormat::setDoubleBuffer()
-*/
-
-void QGLWidget::swapBuffers()
-{
- Q_D(QGLWidget);
- d->glcx->swapBuffers();
-}
-
-
-/*!
- \fn const QGLContext* QGLWidget::overlayContext() const
-
- Returns the overlay context of this widget, or \nullptr if this
- widget has no overlay.
-
- \sa context()
-*/
-const QGLContext* QGLWidget::overlayContext() const
-{
- return nullptr;
-}
-
-/*!
- \fn void QGLWidget::makeOverlayCurrent()
-
- Makes the overlay context of this widget current. Use this if you
- need to issue OpenGL commands to the overlay context outside of
- initializeOverlayGL(), resizeOverlayGL(), and paintOverlayGL().
-
- Does nothing if this widget has no overlay.
-
- \sa makeCurrent()
-*/
-void QGLWidget::makeOverlayCurrent()
-{
-}
-
-/*!
- \obsolete
-
- Sets a new format for this widget.
-
- If the underlying OpenGL/Window system cannot satisfy all the
- features requested in \a format, the nearest subset of features will
- be used. After creation, the format() method will return the actual
- rendering context format obtained.
-
- The widget will be assigned a new QGLContext, and the initializeGL()
- function will be executed for this new context before the first
- resizeGL() or paintGL().
-
- This method will try to keep display list and texture object sharing
- in effect with other QGLWidget objects, but changing the format might make
- sharing impossible. Use isSharing() to see if sharing is still in
- effect.
-
- \sa format(), isSharing(), isValid()
-*/
-
-void QGLWidget::setFormat(const QGLFormat &format)
-{
- setContext(new QGLContext(format,this));
-}
-
-
-
-
-/*!
- \fn QGLContext *QGLWidget::context() const
-
- Returns the context of this widget.
-
- It is possible that the context is not valid (see isValid()), for
- example, if the underlying hardware does not support the format
- attributes that were requested.
-*/
-
-/*!
- \fn void QGLWidget::setContext(QGLContext *context,
- const QGLContext* shareContext,
- bool deleteOldContext)
- \obsolete
-
- Sets a new context for this widget. The QGLContext \a context must
- be created using \e new. QGLWidget will delete \a context when
- another context is set or when the widget is destroyed.
-
- If \a context is invalid, QGLContext::create() is performed on
- it. The initializeGL() function will then be executed for the new
- context before the first resizeGL() or paintGL().
-
- If \a context is invalid, this method will try to keep display list
- and texture object sharing in effect, or (if \a shareContext points
- to a valid context) start display list and texture object sharing
- with that context, but sharing might be impossible if the two
- contexts have different \l {format()} {formats}. Use isSharing() to
- see whether sharing is in effect.
-
- If \a deleteOldContext is true (the default), the existing context
- will be deleted. You may use false here if you have kept a pointer
- to the old context (as returned by context()), and want to restore
- that context later.
-
- \note This function is obsolete and should no longer be used. If you were
- using it to recreate the context for a QGLWidget, you should instead create a
- new QGLWidget or use the QOpenGLContext API in conjunction with QWindow.
- There is currently no officially supported way to substitute QGLWidget's
- context with your own implementation of QGLContext.
-
- \sa context(), isSharing()
-*/
-void QGLWidget::setContext(QGLContext *context,
- const QGLContext* shareContext,
- bool deleteOldContext)
-{
- Q_D(QGLWidget);
- if (context == 0) {
- qWarning("QGLWidget::setContext: Cannot set null context");
- return;
- }
-
- if (context->device() == 0) // a context may refere to more than 1 window.
- context->setDevice(this); //but its better to point to 1 of them than none of them.
-
- QGLContext* oldcx = d->glcx;
- d->glcx = context;
-
- if (!d->glcx->isValid())
- d->glcx->create(shareContext ? shareContext : oldcx);
-
- if (deleteOldContext)
- delete oldcx;
-}
-
-/*!
- \fn void QGLWidget::updateGL()
-
- Updates the widget by calling glDraw().
-*/
-
-void QGLWidget::updateGL()
-{
- Q_D(QGLWidget);
- const bool targetIsOffscreen = !d->glcx->d_ptr->readback_target_size.isEmpty();
- if (updatesEnabled() && (testAttribute(Qt::WA_Mapped) || targetIsOffscreen))
- glDraw();
-}
-
-
-/*!
- \fn void QGLWidget::updateOverlayGL()
-
- Updates the widget's overlay (if any). Will cause the virtual
- function paintOverlayGL() to be executed.
-
- The widget's rendering context will become the current context and
- initializeGL() will be called if it hasn't already been called.
-*/
-void QGLWidget::updateOverlayGL()
-{
-}
-
-/*!
- This virtual function is called once before the first call to
- paintGL() or resizeGL(), and then once whenever the widget has
- been assigned a new QGLContext. Reimplement it in a subclass.
-
- This function should set up any required OpenGL context rendering
- flags, defining display lists, etc.
-
- There is no need to call makeCurrent() because this has already
- been done when this function is called.
-*/
-
-void QGLWidget::initializeGL()
-{
-}
-
-
-/*!
- This virtual function is called whenever the widget needs to be
- painted. Reimplement it in a subclass.
-
- There is no need to call makeCurrent() because this has already
- been done when this function is called.
-*/
-
-void QGLWidget::paintGL()
-{
- qgl_functions()->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-
-
-/*!
- \fn void QGLWidget::resizeGL(int width , int height)
-
- This virtual function is called whenever the widget has been
- resized. The new size is passed in \a width and \a height.
- Reimplement it in a subclass.
-
- There is no need to call makeCurrent() because this has already
- been done when this function is called.
-*/
-
-void QGLWidget::resizeGL(int, int)
-{
-}
-
-
-
-/*!
- This virtual function is used in the same manner as initializeGL()
- except that it operates on the widget's overlay context instead of
- the widget's main context. This means that initializeOverlayGL()
- is called once before the first call to paintOverlayGL() or
- resizeOverlayGL(). Reimplement it in a subclass.
-
- This function should set up any required OpenGL context rendering
- flags, defining display lists, etc. for the overlay context.
-
- There is no need to call makeOverlayCurrent() because this has
- already been done when this function is called.
-*/
-
-void QGLWidget::initializeOverlayGL()
-{
-}
-
-
-/*!
- This virtual function is used in the same manner as paintGL()
- except that it operates on the widget's overlay context instead of
- the widget's main context. This means that paintOverlayGL() is
- called whenever the widget's overlay needs to be painted.
- Reimplement it in a subclass.
-
- There is no need to call makeOverlayCurrent() because this has
- already been done when this function is called.
-*/
-
-void QGLWidget::paintOverlayGL()
-{
-}
-
-
-/*!
- \fn void QGLWidget::resizeOverlayGL(int width , int height)
-
- This virtual function is used in the same manner as paintGL()
- except that it operates on the widget's overlay context instead of
- the widget's main context. This means that resizeOverlayGL() is
- called whenever the widget has been resized. The new size is
- passed in \a width and \a height. Reimplement it in a subclass.
-
- There is no need to call makeOverlayCurrent() because this has
- already been done when this function is called.
-*/
-
-void QGLWidget::resizeOverlayGL(int, int)
-{
-}
-
-/*!\reimp
-*/
-bool QGLWidget::event(QEvent *e)
-{
- Q_D(QGLWidget);
-
- // A re-parent will destroy the window and re-create it. We should not reset the context while it happens.
- if (e->type() == QEvent::ParentAboutToChange)
- d->parent_changing = true;
-
- if (e->type() == QEvent::ParentChange)
- d->parent_changing = false;
-
- return QWidget::event(e);
-}
-
-/*!
- \fn void QGLWidget::paintEvent(QPaintEvent *event)
-
- Handles paint events passed in the \a event parameter. Will cause
- the virtual paintGL() function to be called.
-
- The widget's rendering context will become the current context and
- initializeGL() will be called if it hasn't already been called.
-*/
-
-void QGLWidget::paintEvent(QPaintEvent *)
-{
- if (updatesEnabled()) {
- glDraw();
- updateOverlayGL();
- }
-}
-
-
-/*!
- \fn void QGLWidget::resizeEvent(QResizeEvent *event)
-
- Handles resize events that are passed in the \a event parameter.
- Calls the virtual function resizeGL().
-*/
-void QGLWidget::resizeEvent(QResizeEvent *e)
-{
- Q_D(QGLWidget);
-
- QWidget::resizeEvent(e);
- if (!isValid())
- return;
- if (!d->makeCurrent())
- return;
- if (!d->glcx->initialized())
- glInit();
- const qreal scaleFactor = (window() && window()->windowHandle()) ?
- window()->windowHandle()->devicePixelRatio() : 1.0;
-
- resizeGL(width() * scaleFactor, height() * scaleFactor);
-}
-
-/*!
- Renders the current scene on a pixmap and returns the pixmap.
-
- You can use this method on both visible and invisible QGLWidget objects.
-
- Internally the function renders into a framebuffer object and performs pixel
- readback. This has a performance penalty, meaning that this function is not
- suitable to be called at a high frequency.
-
- After creating and binding the framebuffer object, the function will call
- initializeGL(), resizeGL(), and paintGL(). On the next normal update
- initializeGL() and resizeGL() will be triggered again since the size of the
- destination pixmap and the QGLWidget's size may differ.
-
- The size of the pixmap will be \a w pixels wide and \a h pixels high unless
- one of these parameters is 0 (the default), in which case the pixmap will
- have the same size as the widget.
-
- Care must be taken when using framebuffer objects in paintGL() in
- combination with this function. To switch back to the default framebuffer,
- use QGLFramebufferObject::bindDefault(). Binding FBO 0 is wrong since
- renderPixmap() uses a custom framebuffer instead of the one provided by the
- windowing system.
-
- \a useContext is ignored. Historically this parameter enabled the usage of
- the existing GL context. This is not supported anymore since additional
- contexts are never created.
-
- Overlays are not rendered onto the pixmap.
-
- If the GL rendering context and the desktop have different bit
- depths, the result will most likely look surprising.
-
- Note that the creation of display lists, modifications of the view
- frustum etc. should be done from within initializeGL(). If this is
- not done, the temporary QGLContext will not be initialized
- properly, and the rendered pixmap may be incomplete/corrupted.
-*/
-
-QPixmap QGLWidget::renderPixmap(int w, int h, bool useContext)
-{
- Q_UNUSED(useContext);
- Q_D(QGLWidget);
-
- QSize sz = size();
- if ((w > 0) && (h > 0))
- sz = QSize(w, h);
-
- QPixmap pm;
- if (d->glcx->isValid()) {
- d->glcx->makeCurrent();
- QGLFramebufferObject fbo(sz, QGLFramebufferObject::CombinedDepthStencil);
- fbo.bind();
- d->glcx->setInitialized(false);
- uint prevDefaultFbo = d->glcx->d_ptr->default_fbo;
- d->glcx->d_ptr->default_fbo = fbo.handle();
- d->glcx->d_ptr->readback_target_size = sz;
- updateGL();
- fbo.release();
- pm = QPixmap::fromImage(fbo.toImage());
- d->glcx->d_ptr->default_fbo = prevDefaultFbo;
- d->glcx->setInitialized(false);
- d->glcx->d_ptr->readback_target_size = QSize();
- }
-
- return pm;
-}
-
-/*!
- Returns an image of the frame buffer. If \a withAlpha is true the
- alpha channel is included.
-
- Depending on your hardware, you can explicitly select which color
- buffer to grab with a glReadBuffer() call before calling this
- function.
-
- On QNX the back buffer is not preserved when swapBuffers() is called. The back buffer
- where this function reads from, might thus not contain the same content as the front buffer.
- In order to retrieve what is currently visible on the screen, swapBuffers()
- has to be executed prior to this function call.
-*/
-QImage QGLWidget::grabFrameBuffer(bool withAlpha)
-{
- makeCurrent();
- QImage res;
- qreal pixelRatio = devicePixelRatioF();
- int w = pixelRatio * width();
- int h = pixelRatio * height();
- if (format().rgba())
- res = qt_gl_read_frame_buffer(QSize(w, h), format().alpha(), withAlpha);
- res.setDevicePixelRatio(pixelRatio);
- return res;
-}
-
-
-
-/*!
- Initializes OpenGL for this widget's context. Calls the virtual
- function initializeGL().
-*/
-
-void QGLWidget::glInit()
-{
- Q_D(QGLWidget);
- if (!isValid())
- return;
- if (!d->makeCurrent())
- return;
- initializeGL();
- d->glcx->setInitialized(true);
-}
-
-
-/*!
- Executes the virtual function paintGL().
-
- The widget's rendering context will become the current context and
- initializeGL() will be called if it hasn't already been called.
-*/
-
-void QGLWidget::glDraw()
-{
- Q_D(QGLWidget);
- if (!isValid())
- return;
- if (!d->makeCurrent())
- return;
-#ifndef QT_OPENGL_ES
- if (d->glcx->deviceIsPixmap() && !d->glcx->contextHandle()->isOpenGLES())
- qgl1_functions()->glDrawBuffer(GL_FRONT);
-#endif
- QSize readback_target_size = d->glcx->d_ptr->readback_target_size;
- if (!d->glcx->initialized()) {
- glInit();
- const qreal scaleFactor = (window() && window()->windowHandle()) ?
- window()->windowHandle()->devicePixelRatio() : 1.0;
- int w, h;
- if (readback_target_size.isEmpty()) {
- w = d->glcx->device()->width() * scaleFactor;
- h = d->glcx->device()->height() * scaleFactor;
- } else {
- w = readback_target_size.width();
- h = readback_target_size.height();
- }
- resizeGL(w, h); // New context needs this "resize"
- }
- paintGL();
- if (doubleBuffer() && readback_target_size.isEmpty()) {
- if (d->autoSwap)
- swapBuffers();
- } else {
- qgl_functions()->glFlush();
- }
-}
-
-/*!
- Convenience function for specifying a drawing color to OpenGL.
- Calls glColor4 (in RGBA mode) or glIndex (in color-index mode)
- with the color \a c. Applies to this widgets GL context.
-
- \note This function is not supported on OpenGL/ES 2.0 systems.
-
- \sa qglClearColor(), QGLContext::currentContext(), QColor
-*/
-
-void QGLWidget::qglColor(const QColor& c) const
-{
-#if !defined(QT_OPENGL_ES_2)
-#ifdef QT_OPENGL_ES
- qgl_functions()->glColor4f(c.redF(), c.greenF(), c.blueF(), c.alphaF());
-#else
- Q_D(const QGLWidget);
- const QGLContext *ctx = QGLContext::currentContext();
- if (ctx && !ctx->contextHandle()->isOpenGLES()) {
- if (ctx->format().rgba())
- qgl1_functions()->glColor4f(c.redF(), c.greenF(), c.blueF(), c.alphaF());
- else if (!d->cmap.isEmpty()) { // QGLColormap in use?
- int i = d->cmap.find(c.rgb());
- if (i < 0)
- i = d->cmap.findNearest(c.rgb());
- qgl1_functions()->glIndexi(i);
- } else
- qgl1_functions()->glIndexi(ctx->colorIndex(c));
- }
-#endif //QT_OPENGL_ES
-#else
- Q_UNUSED(c);
-#endif //QT_OPENGL_ES_2
-}
-
-/*!
- Convenience function for specifying the clearing color to OpenGL.
- Calls glClearColor (in RGBA mode) or glClearIndex (in color-index
- mode) with the color \a c. Applies to this widgets GL context.
-
- \sa qglColor(), QGLContext::currentContext(), QColor
-*/
-
-void QGLWidget::qglClearColor(const QColor& c) const
-{
-#ifdef QT_OPENGL_ES
- qgl_functions()->glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
-#else
- Q_D(const QGLWidget);
- const QGLContext *ctx = QGLContext::currentContext();
- if (ctx && !ctx->contextHandle()->isOpenGLES()) {
- if (ctx->format().rgba())
- qgl_functions()->glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
- else if (!d->cmap.isEmpty()) { // QGLColormap in use?
- int i = d->cmap.find(c.rgb());
- if (i < 0)
- i = d->cmap.findNearest(c.rgb());
- qgl1_functions()->glClearIndex(i);
- } else {
- qgl1_functions()->glClearIndex(ctx->colorIndex(c));
- }
- } else {
- qgl_functions()->glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
- }
-#endif
-}
-
-
-/*!
- Converts the image \a img into the unnamed format expected by
- OpenGL functions such as glTexImage2D(). The returned image is not
- usable as a QImage, but QImage::width(), QImage::height() and
- QImage::bits() may be used with OpenGL. The GL format used is
- \c GL_RGBA.
-
- \omit ###
-
- \l opengl/texture example
- The following few lines are from the texture example. Most of the
- code is irrelevant, so we just quote the relevant bits:
-
- \quotefromfile opengl/texture/gltexobj.cpp
- \skipto tex1
- \printline tex1
- \printline gllogo.bmp
-
- We create \e tex1 (and another variable) for OpenGL, and load a real
- image into \e buf.
-
- \skipto convertToGLFormat
- \printline convertToGLFormat
-
- A few lines later, we convert \e buf into OpenGL format and store it
- in \e tex1.
-
- \skipto glTexImage2D
- \printline glTexImage2D
- \printline tex1.bits
-
- Note the dimension restrictions for texture images as described in
- the glTexImage2D() documentation. The width must be 2^m + 2*border
- and the height 2^n + 2*border where m and n are integers and
- border is either 0 or 1.
-
- Another function in the same example uses \e tex1 with OpenGL.
-
- \endomit
-*/
-
-QImage QGLWidget::convertToGLFormat(const QImage& img)
-{
- QImage res(img.size(), QImage::Format_ARGB32);
- convertToGLFormatHelper(res, img.convertToFormat(QImage::Format_ARGB32), GL_RGBA);
- return res;
-}
-
-
-/*!
- \fn QGLColormap & QGLWidget::colormap() const
-
- Returns the colormap for this widget.
-
- Usually it is only top-level widgets that can have different
- colormaps installed. Asking for the colormap of a child widget
- will return the colormap for the child's top-level widget.
-
- If no colormap has been set for this widget, the QGLColormap
- returned will be empty.
-
- \sa setColormap(), QGLColormap::isEmpty()
-*/
-const QGLColormap & QGLWidget::colormap() const
-{
- Q_D(const QGLWidget);
- return d->cmap;
-}
-
-/*!
- \fn void QGLWidget::setColormap(const QGLColormap & cmap)
-
- Set the colormap for this widget to \a cmap. Usually it is only
- top-level widgets that can have colormaps installed.
-
- \sa colormap()
-*/
-void QGLWidget::setColormap(const QGLColormap & c)
-{
- Q_UNUSED(c);
-}
-
-#ifndef QT_OPENGL_ES
-
-static void qt_save_gl_state()
-{
- QOpenGLFunctions *funcs = qgl_functions();
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
-
- gl1funcs->glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
- gl1funcs->glPushAttrib(GL_ALL_ATTRIB_BITS);
- gl1funcs->glMatrixMode(GL_TEXTURE);
- gl1funcs->glPushMatrix();
- gl1funcs->glLoadIdentity();
- gl1funcs->glMatrixMode(GL_PROJECTION);
- gl1funcs->glPushMatrix();
- gl1funcs->glMatrixMode(GL_MODELVIEW);
- gl1funcs->glPushMatrix();
-
- gl1funcs->glShadeModel(GL_FLAT);
- funcs->glDisable(GL_CULL_FACE);
- funcs->glDisable(GL_LIGHTING);
- funcs->glDisable(GL_STENCIL_TEST);
- funcs->glDisable(GL_DEPTH_TEST);
- funcs->glEnable(GL_BLEND);
- funcs->glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-}
-
-static void qt_restore_gl_state()
-{
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
-
- gl1funcs->glMatrixMode(GL_TEXTURE);
- gl1funcs->glPopMatrix();
- gl1funcs->glMatrixMode(GL_PROJECTION);
- gl1funcs->glPopMatrix();
- gl1funcs->glMatrixMode(GL_MODELVIEW);
- gl1funcs->glPopMatrix();
- gl1funcs->glPopAttrib();
- gl1funcs->glPopClientAttrib();
-}
-
-static void qt_gl_draw_text(QPainter *p, int x, int y, const QString &str,
- const QFont &font)
-{
- GLfloat color[4];
- qgl_functions()->glGetFloatv(GL_CURRENT_COLOR, &color[0]);
-
- QColor col;
- col.setRgbF(color[0], color[1], color[2],color[3]);
- QPen old_pen = p->pen();
- QFont old_font = p->font();
-
- p->setPen(col);
- p->setFont(font);
- p->drawText(x, y, str);
-
- p->setPen(old_pen);
- p->setFont(old_font);
-}
-
-#endif // !QT_OPENGL_ES
-
-/*!
- Renders the string \a str into the GL context of this widget.
-
- \a x and \a y are specified in window coordinates, with the origin
- in the upper left-hand corner of the window. If \a font is not
- specified, the currently set application font will be used to
- render the string. To change the color of the rendered text you can
- use the glColor() call (or the qglColor() convenience function),
- just before the renderText() call.
-
- \note This function clears the stencil buffer.
-
- \note This function is not supported on OpenGL/ES systems.
-
- \note This function temporarily disables depth-testing when the
- text is drawn.
-
- \note This function can only be used inside a
- QPainter::beginNativePainting()/QPainter::endNativePainting() block
- if a painter is active on the QGLWidget.
-*/
-
-void QGLWidget::renderText(int x, int y, const QString &str, const QFont &font)
-{
-#ifndef QT_OPENGL_ES
- Q_D(QGLWidget);
- if (!d->glcx->contextHandle()->isOpenGLES()) {
- Q_D(QGLWidget);
- if (str.isEmpty() || !isValid())
- return;
-
- QOpenGLFunctions *funcs = qgl_functions();
- GLint view[4];
- bool use_scissor_testing = funcs->glIsEnabled(GL_SCISSOR_TEST);
- if (!use_scissor_testing)
- funcs->glGetIntegerv(GL_VIEWPORT, &view[0]);
- int width = d->glcx->device()->width();
- int height = d->glcx->device()->height();
- bool auto_swap = autoBufferSwap();
-
- QPaintEngine *engine = paintEngine();
-
- qt_save_gl_state();
-
- QPainter *p;
- bool reuse_painter = false;
- if (engine->isActive()) {
- reuse_painter = true;
- p = engine->painter();
-
- funcs->glDisable(GL_DEPTH_TEST);
- funcs->glViewport(0, 0, width, height);
- } else {
- setAutoBufferSwap(false);
- // disable glClear() as a result of QPainter::begin()
- d->disable_clear_on_painter_begin = true;
- p = new QPainter(this);
- }
-
- QRect viewport(view[0], view[1], view[2], view[3]);
- if (!use_scissor_testing && viewport != rect()) {
- // if the user hasn't set a scissor box, we set one that
- // covers the current viewport
- funcs->glScissor(view[0], view[1], view[2], view[3]);
- funcs->glEnable(GL_SCISSOR_TEST);
- } else if (use_scissor_testing) {
- // use the scissor box set by the user
- funcs->glEnable(GL_SCISSOR_TEST);
- }
-
- qt_gl_draw_text(p, x, y, str, font);
-
- if (!reuse_painter) {
- p->end();
- delete p;
- setAutoBufferSwap(auto_swap);
- d->disable_clear_on_painter_begin = false;
- }
-
- qt_restore_gl_state();
-
- return;
- }
-#else // QT_OPENGL_ES
- Q_UNUSED(x);
- Q_UNUSED(y);
- Q_UNUSED(str);
- Q_UNUSED(font);
-#endif
- qWarning("QGLWidget::renderText is not supported under OpenGL/ES");
-}
-
-/*! \overload
-
- \a x, \a y and \a z are specified in scene or object coordinates
- relative to the currently set projection and model matrices. This
- can be useful if you want to annotate models with text labels and
- have the labels move with the model as it is rotated etc.
-
- \note This function is not supported on OpenGL/ES systems.
-
- \note If depth testing is enabled before this function is called,
- then the drawn text will be depth-tested against the models that
- have already been drawn in the scene. Use \c{glDisable(GL_DEPTH_TEST)}
- before calling this function to annotate the models without
- depth-testing the text.
-
- \note This function can only be used inside a
- QPainter::beginNativePainting()/QPainter::endNativePainting() block
- if a painter is active on the QGLWidget.
-*/
-void QGLWidget::renderText(double x, double y, double z, const QString &str, const QFont &font)
-{
-#ifndef QT_OPENGL_ES
- Q_D(QGLWidget);
- if (!d->glcx->contextHandle()->isOpenGLES()) {
- Q_D(QGLWidget);
- if (str.isEmpty() || !isValid())
- return;
-
- QOpenGLFunctions *funcs = qgl_functions();
- bool auto_swap = autoBufferSwap();
-
- int width = d->glcx->device()->width();
- int height = d->glcx->device()->height();
- GLdouble model[4 * 4], proj[4 * 4];
- GLint view[4];
- QOpenGLFunctions_1_1 *gl1funcs = qgl1_functions();
- gl1funcs->glGetDoublev(GL_MODELVIEW_MATRIX, &model[0]);
- gl1funcs->glGetDoublev(GL_PROJECTION_MATRIX, &proj[0]);
- funcs->glGetIntegerv(GL_VIEWPORT, &view[0]);
- GLdouble win_x = 0, win_y = 0, win_z = 0;
- qgluProject(x, y, z, &model[0], &proj[0], &view[0],
- &win_x, &win_y, &win_z);
- const int dpr = d->glcx->device()->devicePixelRatioF();
- win_x /= dpr;
- win_y /= dpr;
- win_y = height - win_y; // y is inverted
-
- QPaintEngine *engine = paintEngine();
-
- QPainter *p;
- bool reuse_painter = false;
- bool use_depth_testing = funcs->glIsEnabled(GL_DEPTH_TEST);
- bool use_scissor_testing = funcs->glIsEnabled(GL_SCISSOR_TEST);
-
- qt_save_gl_state();
-
- if (engine->isActive()) {
- reuse_painter = true;
- p = engine->painter();
- } else {
- setAutoBufferSwap(false);
- // disable glClear() as a result of QPainter::begin()
- d->disable_clear_on_painter_begin = true;
- p = new QPainter(this);
- }
-
- QRect viewport(view[0], view[1], view[2], view[3]);
- if (!use_scissor_testing && viewport != rect()) {
- funcs->glScissor(view[0], view[1], view[2], view[3]);
- funcs->glEnable(GL_SCISSOR_TEST);
- } else if (use_scissor_testing) {
- funcs->glEnable(GL_SCISSOR_TEST);
- }
- funcs->glViewport(0, 0, width * dpr, height * dpr);
- gl1funcs->glAlphaFunc(GL_GREATER, 0.0);
- funcs->glEnable(GL_ALPHA_TEST);
- if (use_depth_testing)
- funcs->glEnable(GL_DEPTH_TEST);
-
- // The only option in Qt 5 is the shader-based OpenGL 2 paint engine.
- // Setting fixed pipeline transformations is futile. Instead, pass the
- // extra values directly and let the engine figure the matrices out.
- static_cast<QGL2PaintEngineEx *>(p->paintEngine())->setTranslateZ(-2 * win_z);
-
- qt_gl_draw_text(p, qRound(win_x), qRound(win_y), str, font);
-
- static_cast<QGL2PaintEngineEx *>(p->paintEngine())->setTranslateZ(0);
-
- if (!reuse_painter) {
- p->end();
- delete p;
- setAutoBufferSwap(auto_swap);
- d->disable_clear_on_painter_begin = false;
- }
-
- qt_restore_gl_state();
-
- return;
- }
-#else // QT_OPENGL_ES
- Q_UNUSED(x);
- Q_UNUSED(y);
- Q_UNUSED(z);
- Q_UNUSED(str);
- Q_UNUSED(font);
-#endif
- qWarning("QGLWidget::renderText is not supported under OpenGL/ES");
-}
-
-QGLFormat QGLWidget::format() const
-{
- Q_D(const QGLWidget);
- return d->glcx->format();
-}
-
-QGLContext *QGLWidget::context() const
-{
- Q_D(const QGLWidget);
- return d->glcx;
-}
-
-bool QGLWidget::doubleBuffer() const
-{
- Q_D(const QGLWidget);
- return d->glcx->d_ptr->glFormat.testOption(QGL::DoubleBuffer);
-}
-
-void QGLWidget::setAutoBufferSwap(bool on)
-{
- Q_D(QGLWidget);
- d->autoSwap = on;
-}
-
-bool QGLWidget::autoBufferSwap() const
-{
- Q_D(const QGLWidget);
- return d->autoSwap;
-}
-
-/*!
- Calls QGLContext:::bindTexture(\a image, \a target, \a format) on the currently
- set context.
-
- \sa deleteTexture()
-*/
-GLuint QGLWidget::bindTexture(const QImage &image, GLenum target, GLint format)
-{
- if (image.isNull())
- return 0;
-
- Q_D(QGLWidget);
- return d->glcx->bindTexture(image, target, format, QGLContext::DefaultBindOption);
-}
-
-/*!
- \overload
- \since 4.6
-
- The binding \a options are a set of options used to decide how to
- bind the texture to the context.
- */
-GLuint QGLWidget::bindTexture(const QImage &image, GLenum target, GLint format, QGLContext::BindOptions options)
-{
- if (image.isNull())
- return 0;
-
- Q_D(QGLWidget);
- return d->glcx->bindTexture(image, target, format, options);
-}
-
-
-/*!
- Calls QGLContext:::bindTexture(\a pixmap, \a target, \a format) on the currently
- set context.
-
- \sa deleteTexture()
-*/
-GLuint QGLWidget::bindTexture(const QPixmap &pixmap, GLenum target, GLint format)
-{
- if (pixmap.isNull())
- return 0;
-
- Q_D(QGLWidget);
- return d->glcx->bindTexture(pixmap, target, format, QGLContext::DefaultBindOption);
-}
-
-/*!
- \overload
- \since 4.6
-
- Generates and binds a 2D GL texture to the current context, based
- on \a pixmap. The generated texture id is returned and can be used in
-
- The binding \a options are a set of options used to decide how to
- bind the texture to the context.
- */
-GLuint QGLWidget::bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
- QGLContext::BindOptions options)
-{
- Q_D(QGLWidget);
- return d->glcx->bindTexture(pixmap, target, format, options);
-}
-
-/*! \overload
-
- Calls QGLContext::bindTexture(\a fileName) on the currently set context.
-
- \sa deleteTexture()
-*/
-GLuint QGLWidget::bindTexture(const QString &fileName)
-{
- Q_D(QGLWidget);
- return d->glcx->bindTexture(fileName);
-}
-
-/*!
- Calls QGLContext::deleteTexture(\a id) on the currently set
- context.
-
- \sa bindTexture()
-*/
-void QGLWidget::deleteTexture(GLuint id)
-{
- Q_D(QGLWidget);
- d->glcx->deleteTexture(id);
-}
-
-/*!
- \since 4.4
-
- Calls the corresponding QGLContext::drawTexture() with
- \a target, \a textureId, and \a textureTarget for this
- widget's context.
-*/
-void QGLWidget::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
-{
- Q_D(QGLWidget);
- d->glcx->drawTexture(target, textureId, textureTarget);
-}
-
-/*!
- \since 4.4
-
- Calls the corresponding QGLContext::drawTexture() with
- \a point, \a textureId, and \a textureTarget for this
- widget's context.
-*/
-void QGLWidget::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
-{
- Q_D(QGLWidget);
- d->glcx->drawTexture(point, textureId, textureTarget);
-}
-
-Q_GLOBAL_STATIC(QGLEngineThreadStorage<QGL2PaintEngineEx>, qt_gl_2_engine)
-
-Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine()
-{
- return qt_gl_2_engine()->engine();
-}
-
-/*!
- \internal
-
- Returns the GL widget's paint engine.
-*/
-QPaintEngine *QGLWidget::paintEngine() const
-{
- return qt_qgl_paint_engine();
-}
-
-void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget *shareWidget)
-{
- Q_Q(QGLWidget);
- q->setAttribute(Qt::WA_PaintOnScreen);
- q->setAttribute(Qt::WA_NoSystemBackground);
- q->setAutoFillBackground(true); // for compatibility
-
- mustHaveWindowHandle = 1;
- q->setAttribute(Qt::WA_NativeWindow);
- q->setWindowFlag(Qt::MSWindowsOwnDC);
-
- initContext(context, shareWidget);
-}
-
-/*
- This is the shared initialization for all platforms. Called from QGLWidgetPrivate::init()
-*/
-void QGLWidgetPrivate::initContext(QGLContext *context, const QGLWidget* shareWidget)
-{
- Q_Q(QGLWidget);
-
- glDevice.setWidget(q);
-
- glcx = 0;
- autoSwap = true;
-
- if (context && !context->device())
- context->setDevice(q);
- q->setContext(context, shareWidget ? shareWidget->context() : 0);
-
- if (!glcx)
- glcx = new QGLContext(QGLFormat::defaultFormat(), q);
-}
-
-bool QGLWidgetPrivate::renderCxPm(QPixmap*)
-{
- return false;
-}
-
-/*! \internal
- Free up any allocated colormaps. This fn is only called for
- top-level widgets.
-*/
-void QGLWidgetPrivate::cleanupColormaps()
-{
-}
-
-void QGLContextGroup::addShare(const QGLContext *context, const QGLContext *share) {
- Q_ASSERT(context && share);
- if (context->d_ptr->group == share->d_ptr->group)
- return;
-
- // Make sure 'context' is not already shared with another group of contexts.
- Q_ASSERT(context->d_ptr->group->m_refs.loadRelaxed() == 1);
-
- // Free 'context' group resources and make it use the same resources as 'share'.
- QGLContextGroup *group = share->d_ptr->group;
- delete context->d_ptr->group;
- context->d_ptr->group = group;
- group->m_refs.ref();
-
- // Maintain a list of all the contexts in each group of sharing contexts.
- // The list is empty if the "share" context wasn't sharing already.
- if (group->m_shares.isEmpty())
- group->m_shares.append(share);
- group->m_shares.append(context);
-}
-
-void QGLContextGroup::removeShare(const QGLContext *context) {
- // Remove the context from the group.
- QGLContextGroup *group = context->d_ptr->group;
- if (group->m_shares.isEmpty())
- return;
- group->m_shares.removeAll(context);
-
- // Update context group representative.
- Q_ASSERT(group->m_shares.size() != 0);
- if (group->m_context == context)
- group->m_context = group->m_shares.at(0);
-
- // If there is only one context left, then make the list empty.
- if (group->m_shares.size() == 1)
- group->m_shares.clear();
-}
-
-QSize QGLTexture::bindCompressedTexture
- (const QString& fileName, const char *format)
-{
- QFile file(fileName);
- if (!file.open(QIODevice::ReadOnly))
- return QSize();
- QByteArray contents = file.readAll();
- file.close();
- return bindCompressedTexture
- (contents.constData(), contents.size(), format);
-}
-
-// PVR header format for container files that store textures compressed
-// with the ETC1, PVRTC2, and PVRTC4 encodings. Format information from the
-// PowerVR SDK at http://www.imgtec.com/powervr/insider/powervr-sdk.asp
-// "PVRTexTool Reference Manual, version 1.11f".
-struct PvrHeader
-{
- quint32 headerSize;
- quint32 height;
- quint32 width;
- quint32 mipMapCount;
- quint32 flags;
- quint32 dataSize;
- quint32 bitsPerPixel;
- quint32 redMask;
- quint32 greenMask;
- quint32 blueMask;
- quint32 alphaMask;
- quint32 magic;
- quint32 surfaceCount;
-};
-
-#define PVR_MAGIC 0x21525650 // "PVR!" in little-endian
-
-#define PVR_FORMAT_MASK 0x000000FF
-#define PVR_FORMAT_PVRTC2 0x00000018
-#define PVR_FORMAT_PVRTC4 0x00000019
-#define PVR_FORMAT_ETC1 0x00000036
-
-#define PVR_HAS_MIPMAPS 0x00000100
-#define PVR_TWIDDLED 0x00000200
-#define PVR_NORMAL_MAP 0x00000400
-#define PVR_BORDER_ADDED 0x00000800
-#define PVR_CUBE_MAP 0x00001000
-#define PVR_FALSE_COLOR_MIPMAPS 0x00002000
-#define PVR_VOLUME_TEXTURE 0x00004000
-#define PVR_ALPHA_IN_TEXTURE 0x00008000
-#define PVR_VERTICAL_FLIP 0x00010000
-
-#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
-#define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01
-#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
-#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
-#endif
-
-#ifndef GL_ETC1_RGB8_OES
-#define GL_ETC1_RGB8_OES 0x8D64
-#endif
-
-bool QGLTexture::canBindCompressedTexture
- (const char *buf, int len, const char *format, bool *hasAlpha)
-{
- if (QSysInfo::ByteOrder != QSysInfo::LittleEndian) {
- // Compressed texture loading only supported on little-endian
- // systems such as x86 and ARM at the moment.
- return false;
- }
- if (!format) {
- // Auto-detect the format from the header.
- if (len >= 4 && !qstrncmp(buf, "DDS ", 4)) {
- *hasAlpha = true;
- return true;
- } else if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4)) {
- const PvrHeader *pvrHeader =
- reinterpret_cast<const PvrHeader *>(buf);
- *hasAlpha = (pvrHeader->alphaMask != 0);
- return true;
- }
- } else {
- // Validate the format against the header.
- if (!qstricmp(format, "DDS")) {
- if (len >= 4 && !qstrncmp(buf, "DDS ", 4)) {
- *hasAlpha = true;
- return true;
- }
- } else if (!qstricmp(format, "PVR") || !qstricmp(format, "ETC1")) {
- if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4)) {
- const PvrHeader *pvrHeader =
- reinterpret_cast<const PvrHeader *>(buf);
- *hasAlpha = (pvrHeader->alphaMask != 0);
- return true;
- }
- }
- }
- return false;
-}
-
-#define ctx QGLContext::currentContext()
-
-QSize QGLTexture::bindCompressedTexture
- (const char *buf, int len, const char *format)
-{
- if (QSysInfo::ByteOrder != QSysInfo::LittleEndian) {
- // Compressed texture loading only supported on little-endian
- // systems such as x86 and ARM at the moment.
- return QSize();
- }
- if (!format) {
- // Auto-detect the format from the header.
- if (len >= 4 && !qstrncmp(buf, "DDS ", 4))
- return bindCompressedTextureDDS(buf, len);
- else if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4))
- return bindCompressedTexturePVR(buf, len);
- } else {
- // Validate the format against the header.
- if (!qstricmp(format, "DDS")) {
- if (len >= 4 && !qstrncmp(buf, "DDS ", 4))
- return bindCompressedTextureDDS(buf, len);
- } else if (!qstricmp(format, "PVR") || !qstricmp(format, "ETC1")) {
- if (len >= 52 && !qstrncmp(buf + 44, "PVR!", 4))
- return bindCompressedTexturePVR(buf, len);
- }
- }
- return QSize();
-}
-
-QSize QGLTexture::bindCompressedTextureDDS(const char *buf, int len)
-{
- // We only support 2D texture loading at present.
- if (target != GL_TEXTURE_2D)
- return QSize();
-
- // Bail out if the necessary extension is not present.
- if (!qgl_extensions()->hasOpenGLExtension(QOpenGLExtensions::DDSTextureCompression)) {
- qWarning("QGLContext::bindTexture(): DDS texture compression is not supported.");
- return QSize();
- }
-
- const DDSFormat *ddsHeader = reinterpret_cast<const DDSFormat *>(buf + 4);
- if (!ddsHeader->dwLinearSize) {
- qWarning("QGLContext::bindTexture(): DDS image size is not valid.");
- return QSize();
- }
-
- int blockSize = 16;
- GLenum format;
-
- switch(ddsHeader->ddsPixelFormat.dwFourCC) {
- case FOURCC_DXT1:
- format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
- blockSize = 8;
- break;
- case FOURCC_DXT3:
- format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
- break;
- case FOURCC_DXT5:
- format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
- break;
- default:
- qWarning("QGLContext::bindTexture(): DDS image format not supported.");
- return QSize();
- }
-
- const GLubyte *pixels =
- reinterpret_cast<const GLubyte *>(buf + ddsHeader->dwSize + 4);
-
- QOpenGLFunctions *funcs = qgl_functions();
- funcs->glGenTextures(1, &id);
- funcs->glBindTexture(GL_TEXTURE_2D, id);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-
- int size;
- int offset = 0;
- int available = len - int(ddsHeader->dwSize + 4);
- int w = ddsHeader->dwWidth;
- int h = ddsHeader->dwHeight;
-
- // load mip-maps
- for(int i = 0; i < (int) ddsHeader->dwMipMapCount; ++i) {
- if (w == 0) w = 1;
- if (h == 0) h = 1;
-
- size = ((w+3)/4) * ((h+3)/4) * blockSize;
- if (size > available)
- break;
- qgl_extensions()->glCompressedTexImage2D(GL_TEXTURE_2D, i, format, w, h, 0,
- size, pixels + offset);
- offset += size;
- available -= size;
-
- // half size for each mip-map level
- w = w/2;
- h = h/2;
- }
-
- // DDS images are not inverted.
- options &= ~QGLContext::InvertedYBindOption;
-
- return QSize(ddsHeader->dwWidth, ddsHeader->dwHeight);
-}
-
-QSize QGLTexture::bindCompressedTexturePVR(const char *buf, int len)
-{
- // We only support 2D texture loading at present. Cube maps later.
- if (target != GL_TEXTURE_2D)
- return QSize();
-
- // Determine which texture format we will be loading.
- const PvrHeader *pvrHeader = reinterpret_cast<const PvrHeader *>(buf);
- GLenum textureFormat;
- quint32 minWidth, minHeight;
- switch (pvrHeader->flags & PVR_FORMAT_MASK) {
- case PVR_FORMAT_PVRTC2:
- if (pvrHeader->alphaMask)
- textureFormat = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
- else
- textureFormat = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
- minWidth = 16;
- minHeight = 8;
- break;
-
- case PVR_FORMAT_PVRTC4:
- if (pvrHeader->alphaMask)
- textureFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
- else
- textureFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
- minWidth = 8;
- minHeight = 8;
- break;
-
- case PVR_FORMAT_ETC1:
- textureFormat = GL_ETC1_RGB8_OES;
- minWidth = 4;
- minHeight = 4;
- break;
-
- default:
- qWarning("QGLContext::bindTexture(): PVR image format 0x%x not supported.", int(pvrHeader->flags & PVR_FORMAT_MASK));
- return QSize();
- }
-
- // Bail out if the necessary extension is not present.
- if (textureFormat == GL_ETC1_RGB8_OES) {
- if (!qgl_extensions()->hasOpenGLExtension(QOpenGLExtensions::ETC1TextureCompression)) {
- qWarning("QGLContext::bindTexture(): ETC1 texture compression is not supported.");
- return QSize();
- }
- } else {
- if (!qgl_extensions()->hasOpenGLExtension(QOpenGLExtensions::PVRTCTextureCompression)) {
- qWarning("QGLContext::bindTexture(): PVRTC texture compression is not supported.");
- return QSize();
- }
- }
-
- // Boundary check on the buffer size.
- quint32 bufferSize = pvrHeader->headerSize + pvrHeader->dataSize;
- if (bufferSize > quint32(len)) {
- qWarning("QGLContext::bindTexture(): PVR image size is not valid.");
- return QSize();
- }
-
- // Create the texture.
- QOpenGLFunctions *funcs = qgl_functions();
- funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
- funcs->glGenTextures(1, &id);
- funcs->glBindTexture(GL_TEXTURE_2D, id);
- if (pvrHeader->mipMapCount) {
- if ((options & QGLContext::LinearFilteringBindOption) != 0) {
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
- } else {
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
- }
- } else if ((options & QGLContext::LinearFilteringBindOption) != 0) {
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- } else {
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- }
-
- // Load the compressed mipmap levels.
- const GLubyte *buffer =
- reinterpret_cast<const GLubyte *>(buf + pvrHeader->headerSize);
- bufferSize = pvrHeader->dataSize;
- quint32 level = 0;
- quint32 width = pvrHeader->width;
- quint32 height = pvrHeader->height;
- while (bufferSize > 0 && level <= pvrHeader->mipMapCount) {
- quint32 size =
- (qMax(width, minWidth) * qMax(height, minHeight) *
- pvrHeader->bitsPerPixel) / 8;
- if (size > bufferSize)
- break;
- qgl_extensions()->glCompressedTexImage2D(GL_TEXTURE_2D, GLint(level), textureFormat,
- GLsizei(width), GLsizei(height), 0,
- GLsizei(size), buffer);
- width /= 2;
- height /= 2;
- buffer += size;
- ++level;
- }
-
- // Restore the default pixel alignment for later texture uploads.
- funcs->glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-
- // Set the invert flag for the texture. The "vertical flip"
- // flag in PVR is the opposite sense to our sense of inversion.
- options.setFlag(QGLContext::InvertedYBindOption, !(pvrHeader->flags & PVR_VERTICAL_FLIP));
-
- return QSize(pvrHeader->width, pvrHeader->height);
-}
-
-#undef ctx
-
-QT_END_NAMESPACE
diff --git a/src/opengl/qgl.h b/src/opengl/qgl.h
deleted file mode 100644
index f5accbeb3c..0000000000
--- a/src/opengl/qgl.h
+++ /dev/null
@@ -1,524 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGL_H
-#define QGL_H
-
-#ifndef QT_NO_OPENGL
-
-#include <QtGui/qopengl.h>
-#include <QtWidgets/qwidget.h>
-#include <QtGui/qpaintengine.h>
-#include <QtOpenGL/qglcolormap.h>
-#include <QtCore/qmap.h>
-#include <QtCore/qscopedpointer.h>
-
-#include <QtGui/QSurfaceFormat>
-
-QT_BEGIN_NAMESPACE
-
-
-
-
-class QPixmap;
-class QGLWidgetPrivate;
-class QGLContextPrivate;
-
-// Namespace class:
-namespace QGL
-{
- enum FormatOption {
- DoubleBuffer = 0x0001,
- DepthBuffer = 0x0002,
- Rgba = 0x0004,
- AlphaChannel = 0x0008,
- AccumBuffer = 0x0010,
- StencilBuffer = 0x0020,
- StereoBuffers = 0x0040,
- DirectRendering = 0x0080,
- HasOverlay = 0x0100,
- SampleBuffers = 0x0200,
- DeprecatedFunctions = 0x0400,
- SingleBuffer = DoubleBuffer << 16,
- NoDepthBuffer = DepthBuffer << 16,
- ColorIndex = Rgba << 16,
- NoAlphaChannel = AlphaChannel << 16,
- NoAccumBuffer = AccumBuffer << 16,
- NoStencilBuffer = StencilBuffer << 16,
- NoStereoBuffers = StereoBuffers << 16,
- IndirectRendering = DirectRendering << 16,
- NoOverlay = HasOverlay << 16,
- NoSampleBuffers = SampleBuffers << 16,
- NoDeprecatedFunctions = DeprecatedFunctions << 16
- };
- Q_DECLARE_FLAGS(FormatOptions, FormatOption)
-}
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QGL::FormatOptions)
-
-class QGLFormatPrivate;
-
-class Q_OPENGL_EXPORT QGLFormat
-{
-public:
- QGLFormat();
- QGLFormat(QGL::FormatOptions options, int plane = 0);
- QGLFormat(const QGLFormat &other);
- QGLFormat &operator=(const QGLFormat &other);
- ~QGLFormat();
-
- void setDepthBufferSize(int size);
- int depthBufferSize() const;
-
- void setAccumBufferSize(int size);
- int accumBufferSize() const;
-
- void setRedBufferSize(int size);
- int redBufferSize() const;
-
- void setGreenBufferSize(int size);
- int greenBufferSize() const;
-
- void setBlueBufferSize(int size);
- int blueBufferSize() const;
-
- void setAlphaBufferSize(int size);
- int alphaBufferSize() const;
-
- void setStencilBufferSize(int size);
- int stencilBufferSize() const;
-
- void setSampleBuffers(bool enable);
- bool sampleBuffers() const;
-
- void setSamples(int numSamples);
- int samples() const;
-
- void setSwapInterval(int interval);
- int swapInterval() const;
-
- bool doubleBuffer() const;
- void setDoubleBuffer(bool enable);
- bool depth() const;
- void setDepth(bool enable);
- bool rgba() const;
- void setRgba(bool enable);
- bool alpha() const;
- void setAlpha(bool enable);
- bool accum() const;
- void setAccum(bool enable);
- bool stencil() const;
- void setStencil(bool enable);
- bool stereo() const;
- void setStereo(bool enable);
- bool directRendering() const;
- void setDirectRendering(bool enable);
- bool hasOverlay() const;
- void setOverlay(bool enable);
-
- int plane() const;
- void setPlane(int plane);
-
- void setOption(QGL::FormatOptions opt);
- bool testOption(QGL::FormatOptions opt) const;
-
- static QGLFormat defaultFormat();
- static void setDefaultFormat(const QGLFormat& f);
-
- static QGLFormat defaultOverlayFormat();
- static void setDefaultOverlayFormat(const QGLFormat& f);
-
- static bool hasOpenGL();
- static bool hasOpenGLOverlays();
-
- void setVersion(int major, int minor);
- int majorVersion() const;
- int minorVersion() const;
-
- enum OpenGLContextProfile {
- NoProfile,
- CoreProfile,
- CompatibilityProfile
- };
-
- void setProfile(OpenGLContextProfile profile);
- OpenGLContextProfile profile() const;
-
- enum OpenGLVersionFlag {
- OpenGL_Version_None = 0x00000000,
- OpenGL_Version_1_1 = 0x00000001,
- OpenGL_Version_1_2 = 0x00000002,
- OpenGL_Version_1_3 = 0x00000004,
- OpenGL_Version_1_4 = 0x00000008,
- OpenGL_Version_1_5 = 0x00000010,
- OpenGL_Version_2_0 = 0x00000020,
- OpenGL_Version_2_1 = 0x00000040,
- OpenGL_ES_Common_Version_1_0 = 0x00000080,
- OpenGL_ES_CommonLite_Version_1_0 = 0x00000100,
- OpenGL_ES_Common_Version_1_1 = 0x00000200,
- OpenGL_ES_CommonLite_Version_1_1 = 0x00000400,
- OpenGL_ES_Version_2_0 = 0x00000800,
- OpenGL_Version_3_0 = 0x00001000,
- OpenGL_Version_3_1 = 0x00002000,
- OpenGL_Version_3_2 = 0x00004000,
- OpenGL_Version_3_3 = 0x00008000,
- OpenGL_Version_4_0 = 0x00010000,
- OpenGL_Version_4_1 = 0x00020000,
- OpenGL_Version_4_2 = 0x00040000,
- OpenGL_Version_4_3 = 0x00080000
- };
- Q_DECLARE_FLAGS(OpenGLVersionFlags, OpenGLVersionFlag)
-
- static OpenGLVersionFlags openGLVersionFlags();
-
- static QGLFormat fromSurfaceFormat(const QSurfaceFormat &format);
- static QSurfaceFormat toSurfaceFormat(const QGLFormat &format);
-private:
- QGLFormatPrivate *d;
-
- void detach();
-
- friend Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&);
- friend Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&);
-#ifndef QT_NO_DEBUG_STREAM
- friend Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &);
-#endif
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QGLFormat::OpenGLVersionFlags)
-
-Q_OPENGL_EXPORT bool operator==(const QGLFormat&, const QGLFormat&);
-Q_OPENGL_EXPORT bool operator!=(const QGLFormat&, const QGLFormat&);
-
-#ifndef QT_NO_DEBUG_STREAM
-Q_OPENGL_EXPORT QDebug operator<<(QDebug, const QGLFormat &);
-#endif
-
-class QGLFunctions;
-
-class Q_OPENGL_EXPORT QGLContext
-{
- Q_DECLARE_PRIVATE(QGLContext)
-public:
- QGLContext(const QGLFormat& format, QPaintDevice* device);
- QGLContext(const QGLFormat& format);
- virtual ~QGLContext();
-
- virtual bool create(const QGLContext* shareContext = nullptr);
- bool isValid() const;
- bool isSharing() const;
- void reset();
-
- static bool areSharing(const QGLContext *context1, const QGLContext *context2);
-
- QGLFormat format() const;
- QGLFormat requestedFormat() const;
- void setFormat(const QGLFormat& format);
-
- void moveToThread(QThread *thread);
-
- virtual void makeCurrent();
- virtual void doneCurrent();
-
- virtual void swapBuffers() const;
-
- QGLFunctions *functions() const;
-
- enum BindOption {
- NoBindOption = 0x0000,
- InvertedYBindOption = 0x0001,
- MipmapBindOption = 0x0002,
- PremultipliedAlphaBindOption = 0x0004,
- LinearFilteringBindOption = 0x0008,
-
- MemoryManagedBindOption = 0x0010, // internal flag
- CanFlipNativePixmapBindOption = 0x0020, // internal flag
- TemporarilyCachedBindOption = 0x0040, // internal flag
-
- DefaultBindOption = LinearFilteringBindOption
- | InvertedYBindOption
- | MipmapBindOption,
- InternalBindOption = MemoryManagedBindOption
- | PremultipliedAlphaBindOption
- };
- Q_DECLARE_FLAGS(BindOptions, BindOption)
-
- GLuint bindTexture(const QImage &image, GLenum target, GLint format,
- BindOptions options);
- GLuint bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
- BindOptions options);
-
- GLuint bindTexture(const QImage &image, GLenum target = GL_TEXTURE_2D,
- GLint format = GL_RGBA);
- GLuint bindTexture(const QPixmap &pixmap, GLenum target = GL_TEXTURE_2D,
- GLint format = GL_RGBA);
- GLuint bindTexture(const QString &fileName);
-
- void deleteTexture(GLuint tx_id);
-
- void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
- void drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
-
- static void setTextureCacheLimit(int size);
- static int textureCacheLimit();
-
- QFunctionPointer getProcAddress(const QString &proc) const;
- QPaintDevice* device() const;
- QColor overlayTransparentColor() const;
-
- static const QGLContext* currentContext();
-
- static QGLContext *fromOpenGLContext(QOpenGLContext *platformContext);
- QOpenGLContext *contextHandle() const;
-
-protected:
- virtual bool chooseContext(const QGLContext* shareContext = nullptr);
-
- bool deviceIsPixmap() const;
- bool windowCreated() const;
- void setWindowCreated(bool on);
- bool initialized() const;
- void setInitialized(bool on);
-
- uint colorIndex(const QColor& c) const;
- void setValid(bool valid);
- void setDevice(QPaintDevice *pDev);
-
-protected:
- static QGLContext* currentCtx;
-
-private:
- QGLContext(QOpenGLContext *windowContext);
-
- QScopedPointer<QGLContextPrivate> d_ptr;
-
- friend class QGLPixelBuffer;
- friend class QGLPixelBufferPrivate;
- friend class QGLWidget;
- friend class QGLWidgetPrivate;
- friend class QGLGlyphCache;
- friend class QGL2PaintEngineEx;
- friend class QGL2PaintEngineExPrivate;
- friend class QGLEngineShaderManager;
- friend class QGLTextureGlyphCache;
- friend struct QGLGlyphTexture;
- friend class QGLContextGroup;
- friend class QGLPixmapBlurFilter;
- friend class QGLTexture;
- friend QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags();
- friend class QGLFramebufferObject;
- friend class QGLFramebufferObjectPrivate;
- friend class QGLFBOGLPaintDevice;
- friend class QGLPaintDevice;
- friend class QGLWidgetGLPaintDevice;
- friend class QX11GLSharedContexts;
- friend class QGLContextResourceBase;
- friend class QSGDistanceFieldGlyphCache;
-private:
- Q_DISABLE_COPY(QGLContext)
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QGLContext::BindOptions)
-
-class Q_OPENGL_EXPORT QGLWidget : public QWidget
-{
- Q_OBJECT
- Q_DECLARE_PRIVATE(QGLWidget)
-public:
- explicit QGLWidget(QWidget* parent=nullptr,
- const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags());
- explicit QGLWidget(QGLContext *context, QWidget* parent=nullptr,
- const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags());
- explicit QGLWidget(const QGLFormat& format, QWidget* parent=nullptr,
- const QGLWidget* shareWidget = nullptr, Qt::WindowFlags f=Qt::WindowFlags());
- ~QGLWidget();
-
- void qglColor(const QColor& c) const;
- void qglClearColor(const QColor& c) const;
-
- bool isValid() const;
- bool isSharing() const;
-
- void makeCurrent();
- void doneCurrent();
-
- bool doubleBuffer() const;
- void swapBuffers();
-
- QGLFormat format() const;
- void setFormat(const QGLFormat& format);
-
- QGLContext* context() const;
- void setContext(QGLContext* context, const QGLContext* shareContext = nullptr,
- bool deleteOldContext = true);
-
- QPixmap renderPixmap(int w = 0, int h = 0, bool useContext = false);
- QImage grabFrameBuffer(bool withAlpha = false);
-
- void makeOverlayCurrent();
- const QGLContext* overlayContext() const;
-
- static QImage convertToGLFormat(const QImage& img);
-
- const QGLColormap & colormap() const;
- void setColormap(const QGLColormap & map);
-
- void renderText(int x, int y, const QString & str,
- const QFont & fnt = QFont());
- void renderText(double x, double y, double z, const QString & str,
- const QFont & fnt = QFont());
- QPaintEngine *paintEngine() const override;
-
- GLuint bindTexture(const QImage &image, GLenum target, GLint format,
- QGLContext::BindOptions options);
- GLuint bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
- QGLContext::BindOptions options);
-
- GLuint bindTexture(const QImage &image, GLenum target = GL_TEXTURE_2D,
- GLint format = GL_RGBA);
- GLuint bindTexture(const QPixmap &pixmap, GLenum target = GL_TEXTURE_2D,
- GLint format = GL_RGBA);
-
- GLuint bindTexture(const QString &fileName);
-
- void deleteTexture(GLuint tx_id);
-
- void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
- void drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
-
-public Q_SLOTS:
- virtual void updateGL();
- virtual void updateOverlayGL();
-
-protected:
- bool event(QEvent *) override;
- virtual void initializeGL();
- virtual void resizeGL(int w, int h);
- virtual void paintGL();
-
- virtual void initializeOverlayGL();
- virtual void resizeOverlayGL(int w, int h);
- virtual void paintOverlayGL();
-
- void setAutoBufferSwap(bool on);
- bool autoBufferSwap() const;
-
- void paintEvent(QPaintEvent*) override;
- void resizeEvent(QResizeEvent*) override;
-
- virtual void glInit();
- virtual void glDraw();
-
- QGLWidget(QGLWidgetPrivate &dd,
- const QGLFormat &format = QGLFormat(),
- QWidget *parent = nullptr,
- const QGLWidget* shareWidget = nullptr,
- Qt::WindowFlags f = Qt::WindowFlags());
-private:
- Q_DISABLE_COPY(QGLWidget)
-
- friend class QGLDrawable;
- friend class QGLPixelBuffer;
- friend class QGLPixelBufferPrivate;
- friend class QGLContext;
- friend class QGLContextPrivate;
- friend class QGLOverlayWidget;
- friend class QGLPaintDevice;
- friend class QGLWidgetGLPaintDevice;
-};
-
-
-//
-// QGLFormat inline functions
-//
-
-inline bool QGLFormat::doubleBuffer() const
-{
- return testOption(QGL::DoubleBuffer);
-}
-
-inline bool QGLFormat::depth() const
-{
- return testOption(QGL::DepthBuffer);
-}
-
-inline bool QGLFormat::rgba() const
-{
- return testOption(QGL::Rgba);
-}
-
-inline bool QGLFormat::alpha() const
-{
- return testOption(QGL::AlphaChannel);
-}
-
-inline bool QGLFormat::accum() const
-{
- return testOption(QGL::AccumBuffer);
-}
-
-inline bool QGLFormat::stencil() const
-{
- return testOption(QGL::StencilBuffer);
-}
-
-inline bool QGLFormat::stereo() const
-{
- return testOption(QGL::StereoBuffers);
-}
-
-inline bool QGLFormat::directRendering() const
-{
- return testOption(QGL::DirectRendering);
-}
-
-inline bool QGLFormat::hasOverlay() const
-{
- return testOption(QGL::HasOverlay);
-}
-
-inline bool QGLFormat::sampleBuffers() const
-{
- return testOption(QGL::SampleBuffers);
-}
-
-QT_END_NAMESPACE
-
-#endif // QT_NO_OPENGL
-#endif // QGL_H
diff --git a/src/opengl/qgl_p.h b/src/opengl/qgl_p.h
deleted file mode 100644
index 4e52c0f5e9..0000000000
--- a/src/opengl/qgl_p.h
+++ /dev/null
@@ -1,556 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGL_P_H
-#define QGL_P_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists for the convenience
-// of the QGLWidget class. This header file may change from
-// version to version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include "QtOpenGL/qgl.h"
-#include "QtOpenGL/qglcolormap.h"
-#include "QtCore/qmap.h"
-#include "QtCore/qthread.h"
-#include "QtCore/qthreadstorage.h"
-#include "QtCore/qhashfunctions.h"
-#include "QtCore/qatomic.h"
-#include "QtWidgets/private/qwidget_p.h"
-#include "QtGui/private/qopenglcontext_p.h"
-#include "QtGui/private/qopenglextensions_p.h"
-#include "qcache.h"
-#include "qglpaintdevice_p.h"
-
-#include <QtGui/QOpenGLContext>
-
-QT_BEGIN_NAMESPACE
-
-class QGLContext;
-class QGLOverlayWidget;
-class QPixmap;
-class QOpenGLExtensions;
-
-class QGLFormatPrivate
-{
-public:
- QGLFormatPrivate()
- : ref(1)
- {
- opts = QGL::DoubleBuffer | QGL::DepthBuffer | QGL::Rgba | QGL::DirectRendering
- | QGL::StencilBuffer | QGL::DeprecatedFunctions;
- pln = 0;
- depthSize = accumSize = stencilSize = redSize = greenSize = blueSize = alphaSize = -1;
- numSamples = -1;
- swapInterval = -1;
- majorVersion = 2;
- minorVersion = 0;
- profile = QGLFormat::NoProfile;
- }
- QGLFormatPrivate(const QGLFormatPrivate *other)
- : ref(1),
- opts(other->opts),
- pln(other->pln),
- depthSize(other->depthSize),
- accumSize(other->accumSize),
- stencilSize(other->stencilSize),
- redSize(other->redSize),
- greenSize(other->greenSize),
- blueSize(other->blueSize),
- alphaSize(other->alphaSize),
- numSamples(other->numSamples),
- swapInterval(other->swapInterval),
- majorVersion(other->majorVersion),
- minorVersion(other->minorVersion),
- profile(other->profile)
- {
- }
- QAtomicInt ref;
- QGL::FormatOptions opts;
- int pln;
- int depthSize;
- int accumSize;
- int stencilSize;
- int redSize;
- int greenSize;
- int blueSize;
- int alphaSize;
- int numSamples;
- int swapInterval;
- int majorVersion;
- int minorVersion;
- QGLFormat::OpenGLContextProfile profile;
-};
-
-class Q_OPENGL_EXPORT QGLWidgetPrivate : public QWidgetPrivate
-{
- Q_DECLARE_PUBLIC(QGLWidget)
-public:
- QGLWidgetPrivate() : QWidgetPrivate()
- , disable_clear_on_painter_begin(false)
- , parent_changing(false)
- {
- }
-
- ~QGLWidgetPrivate() {}
-
- void init(QGLContext *context, const QGLWidget* shareWidget);
- void initContext(QGLContext *context, const QGLWidget* shareWidget);
- bool renderCxPm(QPixmap *pixmap);
- void cleanupColormaps();
- void aboutToDestroy() override {
- if (glcx && !parent_changing)
- glcx->reset();
- }
-
- bool makeCurrent();
-
- QGLContext *glcx;
- QGLWidgetGLPaintDevice glDevice;
- bool autoSwap;
-
- QGLColormap cmap;
-
- bool disable_clear_on_painter_begin;
- bool parent_changing;
-};
-
-// QGLContextPrivate has the responsibility of creating context groups.
-// QGLContextPrivate maintains the reference counter and destroys
-// context groups when needed.
-class QGLContextGroup
-{
-public:
- ~QGLContextGroup();
-
- const QGLContext *context() const {return m_context;}
- bool isSharing() const { return m_shares.size() >= 2; }
- QList<const QGLContext *> shares() const { return m_shares; }
-
- static void addShare(const QGLContext *context, const QGLContext *share);
- static void removeShare(const QGLContext *context);
-
-private:
- QGLContextGroup(const QGLContext *context);
-
- const QGLContext *m_context; // context group's representative
- QList<const QGLContext *> m_shares;
- QAtomicInt m_refs;
-
- friend class QGLContext;
- friend class QGLContextPrivate;
- friend class QGLContextGroupResourceBase;
-};
-
-// Get the context that resources for "ctx" will transfer to once
-// "ctx" is destroyed. Returns null if nothing is sharing with ctx.
-const QGLContext *qt_gl_transfer_context(const QGLContext *);
-
-/*
- QGLTemporaryContext - the main objective of this class is to have a way of
- creating a GL context and making it current, without going via QGLWidget
- and friends. At certain points during GL initialization we need a current
- context in order decide what GL features are available, and to resolve GL
- extensions. Having a light-weight way of creating such a context saves
- initial application startup time, and it doesn't wind up creating recursive
- conflicts.
- The class currently uses a private d pointer to hide the platform specific
- types. This could possibly been done inline with #ifdef'ery, but it causes
- major headaches on e.g. X11 due to namespace pollution.
-*/
-class QGLTemporaryContextPrivate;
-class QGLTemporaryContext {
-public:
- explicit QGLTemporaryContext(bool directRendering = true, QWidget *parent = nullptr);
- ~QGLTemporaryContext();
-
-private:
- QScopedPointer<QGLTemporaryContextPrivate> d;
-};
-
-class QGLTexture;
-class QGLTextureDestroyer;
-
-// This probably needs to grow to GL_MAX_VERTEX_ATTRIBS, but 3 is ok for now as that's
-// all the GL2 engine uses:
-#define QT_GL_VERTEX_ARRAY_TRACKED_COUNT 3
-
-class QGLContextResourceBase;
-
-class QGLContextPrivate
-{
- Q_DECLARE_PUBLIC(QGLContext)
-public:
- explicit QGLContextPrivate(QGLContext *context);
- ~QGLContextPrivate();
- QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format,
- QGLContext::BindOptions options);
- QGLTexture *bindTexture(const QImage &image, GLenum target, GLint format, const qint64 key,
- QGLContext::BindOptions options);
- QGLTexture *bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
- QGLContext::BindOptions options);
- QGLTexture *textureCacheLookup(const qint64 key, GLenum target);
- void init(QPaintDevice *dev, const QGLFormat &format);
- int maxTextureSize();
-
- void cleanup();
-
- void setVertexAttribArrayEnabled(int arrayIndex, bool enabled = true);
- void syncGlState(); // Makes sure the GL context's state is what we think it is
- void swapRegion(const QRegion &region);
-
- QOpenGLContext *guiGlContext;
- // true if QGLContext owns the QOpenGLContext (for who deletes who)
- bool ownContext;
-
- void setupSharing();
- void refreshCurrentFbo();
- void setCurrentFbo(GLuint fbo);
-
- QGLFormat glFormat;
- QGLFormat reqFormat;
- GLuint fbo;
-
- uint valid : 1;
- uint sharing : 1;
- uint initDone : 1;
- uint crWin : 1;
- uint internal_context : 1;
- uint version_flags_cached : 1;
-
- // workarounds for driver/hw bugs on different platforms
- uint workaround_needsFullClearOnEveryFrame : 1;
- uint workaround_brokenFBOReadBack : 1;
- uint workaround_brokenTexSubImage : 1;
- uint workaroundsCached : 1;
-
- uint workaround_brokenTextureFromPixmap : 1;
- uint workaround_brokenTextureFromPixmap_init : 1;
-
- uint workaround_brokenAlphaTexSubImage : 1;
- uint workaround_brokenAlphaTexSubImage_init : 1;
-
- QPaintDevice *paintDevice;
- QSize readback_target_size;
- QColor transpColor;
- QGLContext *q_ptr;
- QGLFormat::OpenGLVersionFlags version_flags;
-
- QGLContextGroup *group;
- GLint max_texture_size;
-
- GLuint current_fbo;
- GLuint default_fbo;
- QPaintEngine *active_engine;
- QGLTextureDestroyer *texture_destroyer;
-
- QGLFunctions *functions;
-
- bool vertexAttributeArraysEnabledState[QT_GL_VERTEX_ARRAY_TRACKED_COUNT];
-
- static inline QGLContextGroup *contextGroup(const QGLContext *ctx) { return ctx->d_ptr->group; }
-
- static void setCurrentContext(QGLContext *context);
-};
-
-// Temporarily make a context current if not already current or
-// shared with the current contex. The previous context is made
-// current when the object goes out of scope.
-class Q_OPENGL_EXPORT QGLShareContextScope
-{
-public:
- QGLShareContextScope(const QGLContext *ctx)
- : m_oldContext(nullptr)
- {
- QGLContext *currentContext = const_cast<QGLContext *>(QGLContext::currentContext());
- if (currentContext != ctx && !QGLContext::areSharing(ctx, currentContext)) {
- m_oldContext = currentContext;
- m_ctx = const_cast<QGLContext *>(ctx);
- m_ctx->makeCurrent();
- } else {
- m_ctx = currentContext;
- }
- }
-
- operator QGLContext *()
- {
- return m_ctx;
- }
-
- QGLContext *operator->()
- {
- return m_ctx;
- }
-
- ~QGLShareContextScope()
- {
- if (m_oldContext)
- m_oldContext->makeCurrent();
- }
-
-private:
- QGLContext *m_oldContext;
- QGLContext *m_ctx;
-};
-
-QT_END_NAMESPACE
-Q_DECLARE_METATYPE(GLuint)
-QT_BEGIN_NAMESPACE
-
-class Q_OPENGL_EXPORT QGLTextureDestroyer
-{
-public:
- void emitFreeTexture(QGLContext *context, QPlatformPixmap *, GLuint id) {
- if (context->contextHandle())
- (new QOpenGLSharedResourceGuard(context->contextHandle(), id, freeTextureFunc))->free();
- }
-
-private:
- static void freeTextureFunc(QOpenGLFunctions *, GLuint id) {
- QOpenGLContext::currentContext()->functions()->glDeleteTextures(1, &id);
- }
-};
-
-class Q_OPENGL_EXPORT QGLSignalProxy : public QObject
-{
- Q_OBJECT
-public:
- void emitAboutToDestroyContext(const QGLContext *context) {
- emit aboutToDestroyContext(context);
- }
- static QGLSignalProxy *instance();
-Q_SIGNALS:
- void aboutToDestroyContext(const QGLContext *context);
-};
-
-class QGLTexture {
-public:
- explicit QGLTexture(QGLContext *ctx = nullptr, GLuint tx_id = 0, GLenum tx_target = GL_TEXTURE_2D,
- QGLContext::BindOptions opt = QGLContext::DefaultBindOption)
- : context(ctx),
- id(tx_id),
- target(tx_target),
- options(opt)
- {}
-
- ~QGLTexture() {
- if (options & QGLContext::MemoryManagedBindOption) {
- Q_ASSERT(context);
- QPlatformPixmap *boundPixmap = nullptr;
- context->d_ptr->texture_destroyer->emitFreeTexture(context, boundPixmap, id);
- }
- }
-
- QGLContext *context;
- GLuint id;
- GLenum target;
-
- QGLContext::BindOptions options;
-
- bool canBindCompressedTexture
- (const char *buf, int len, const char *format, bool *hasAlpha);
- QSize bindCompressedTexture
- (const QString& fileName, const char *format = nullptr);
- QSize bindCompressedTexture
- (const char *buf, int len, const char *format = nullptr);
- QSize bindCompressedTextureDDS(const char *buf, int len);
- QSize bindCompressedTexturePVR(const char *buf, int len);
-};
-
-struct QGLTextureCacheKey {
- qint64 key;
- QGLContextGroup *group;
-};
-
-inline bool operator==(const QGLTextureCacheKey &a, const QGLTextureCacheKey &b)
-{
- return a.key == b.key && a.group == b.group;
-}
-
-inline uint qHash(const QGLTextureCacheKey &key)
-{
- return qHash(key.key) ^ qHash(key.group);
-}
-
-
-class Q_AUTOTEST_EXPORT QGLTextureCache {
-public:
- QGLTextureCache();
- ~QGLTextureCache();
-
- void insert(QGLContext *ctx, qint64 key, QGLTexture *texture, int cost);
- void remove(qint64 key);
- inline int size();
- inline void setMaxCost(int newMax);
- inline int maxCost();
- inline QGLTexture* getTexture(QGLContext *ctx, qint64 key);
-
- bool remove(QGLContext *ctx, GLuint textureId);
- void removeContextTextures(QGLContext *ctx);
- static QGLTextureCache *instance();
- static void cleanupTexturesForCacheKey(qint64 cacheKey);
- static void cleanupTexturesForPixampData(QPlatformPixmap* pixmap);
- static void cleanupBeforePixmapDestruction(QPlatformPixmap* pixmap);
-
-private:
- QCache<QGLTextureCacheKey, QGLTexture> m_cache;
- QReadWriteLock m_lock;
-};
-
-int QGLTextureCache::size() {
- QReadLocker locker(&m_lock);
- return m_cache.size();
-}
-
-void QGLTextureCache::setMaxCost(int newMax)
-{
- QWriteLocker locker(&m_lock);
- m_cache.setMaxCost(newMax);
-}
-
-int QGLTextureCache::maxCost()
-{
- QReadLocker locker(&m_lock);
- return m_cache.maxCost();
-}
-
-QGLTexture* QGLTextureCache::getTexture(QGLContext *ctx, qint64 key)
-{
- // Can't be a QReadLocker since QCache::object() modifies the cache (reprioritizes the object)
- QWriteLocker locker(&m_lock);
- const QGLTextureCacheKey cacheKey = {key, QGLContextPrivate::contextGroup(ctx)};
- return m_cache.object(cacheKey);
-}
-
-Q_OPENGL_EXPORT extern QPaintEngine* qt_qgl_paint_engine();
-
-QOpenGLExtensions* qgl_extensions();
-bool qgl_hasFeature(QOpenGLFunctions::OpenGLFeature feature);
-bool qgl_hasExtension(QOpenGLExtensions::OpenGLExtension extension);
-
-// Put a guard around a GL object identifier and its context.
-// When the context goes away, a shared context will be used
-// in its place. If there are no more shared contexts, then
-// the identifier is returned as zero - it is assumed that the
-// context destruction cleaned up the identifier in this case.
-class QGLSharedResourceGuardBase : public QOpenGLSharedResource
-{
-public:
- QGLSharedResourceGuardBase(QGLContext *context, GLuint id)
- : QOpenGLSharedResource(context->contextHandle()->shareGroup())
- , m_id(id)
- {
- }
-
- GLuint id() const
- {
- return m_id;
- }
-
-protected:
- void invalidateResource() override
- {
- m_id = 0;
- }
-
- void freeResource(QOpenGLContext *context) override
- {
- if (m_id) {
- freeResource(QGLContext::fromOpenGLContext(context), m_id);
- }
- }
-
- virtual void freeResource(QGLContext *ctx, GLuint id) = 0;
-
-private:
- GLuint m_id;
-};
-
-template <typename Func>
-class QGLSharedResourceGuard : public QGLSharedResourceGuardBase
-{
-public:
- QGLSharedResourceGuard(QGLContext *context, GLuint id, Func func)
- : QGLSharedResourceGuardBase(context, id)
- , m_func(func)
- {
- }
-
-protected:
- void freeResource(QGLContext *ctx, GLuint id) override
- {
- m_func(ctx, id);
- }
-
-private:
- Func m_func;
-};
-
-template <typename Func>
-QGLSharedResourceGuardBase *createSharedResourceGuard(QGLContext *context, GLuint id, Func cleanupFunc)
-{
- return new QGLSharedResourceGuard<Func>(context, id, cleanupFunc);
-}
-
-// this is a class that wraps a QThreadStorage object for storing
-// thread local instances of the GL 1 and GL 2 paint engines
-
-template <class T>
-class QGLEngineThreadStorage
-{
-public:
- QPaintEngine *engine() {
- QPaintEngine *&localEngine = storage.localData();
- if (!localEngine)
- localEngine = new T;
- return localEngine;
- }
-
-private:
- QThreadStorage<QPaintEngine *> storage;
-};
-QT_END_NAMESPACE
-
-#endif // QGL_P_H
diff --git a/src/opengl/qglbuffer.cpp b/src/opengl/qglbuffer.cpp
deleted file mode 100644
index bb9c2affbd..0000000000
--- a/src/opengl/qglbuffer.cpp
+++ /dev/null
@@ -1,568 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <QtOpenGL/qgl.h>
-#include <QtOpenGL/private/qgl_p.h>
-#include <private/qopenglextensions_p.h>
-#include <QtCore/qatomic.h>
-#include "qglbuffer.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
- \class QGLBuffer
- \inmodule QtOpenGL
- \brief The QGLBuffer class provides functions for creating and managing GL buffer objects.
- \since 4.7
- \obsolete
- \ingroup painting-3D
-
- Buffer objects are created in the GL server so that the
- client application can avoid uploading vertices, indices,
- texture image data, etc every time they are needed.
-
- QGLBuffer objects can be copied around as a reference to the
- underlying GL buffer object:
-
- \snippet code/src_opengl_qglbuffer.cpp 0
-
- QGLBuffer performs a shallow copy when objects are copied in this
- manner, but does not implement copy-on-write semantics. The original
- object will be affected whenever the copy is modified.
-
- \note This class has been deprecated in favor of QOpenGLBuffer.
-*/
-
-/*!
- \enum QGLBuffer::Type
- This enum defines the type of GL buffer object to create with QGLBuffer.
-
- \value VertexBuffer Vertex buffer object for use when specifying
- vertex arrays.
- \value IndexBuffer Index buffer object for use with \c{glDrawElements()}.
- \value PixelPackBuffer Pixel pack buffer object for reading pixel
- data from the GL server (for example, with \c{glReadPixels()}).
- Not supported under OpenGL/ES.
- \value PixelUnpackBuffer Pixel unpack buffer object for writing pixel
- data to the GL server (for example, with \c{glTexImage2D()}).
- Not supported under OpenGL/ES.
-*/
-
-/*!
- \enum QGLBuffer::UsagePattern
- This enum defines the usage pattern of a QGLBuffer object.
-
- \value StreamDraw The data will be set once and used a few times
- for drawing operations. Under OpenGL/ES 1.1 this is identical
- to StaticDraw.
- \value StreamRead The data will be set once and used a few times
- for reading data back from the GL server. Not supported
- under OpenGL/ES.
- \value StreamCopy The data will be set once and used a few times
- for reading data back from the GL server for use in further
- drawing operations. Not supported under OpenGL/ES.
- \value StaticDraw The data will be set once and used many times
- for drawing operations.
- \value StaticRead The data will be set once and used many times
- for reading data back from the GL server. Not supported
- under OpenGL/ES.
- \value StaticCopy The data will be set once and used many times
- for reading data back from the GL server for use in further
- drawing operations. Not supported under OpenGL/ES.
- \value DynamicDraw The data will be modified repeatedly and used
- many times for drawing operations.
- \value DynamicRead The data will be modified repeatedly and used
- many times for reading data back from the GL server.
- Not supported under OpenGL/ES.
- \value DynamicCopy The data will be modified repeatedly and used
- many times for reading data back from the GL server for
- use in further drawing operations. Not supported under OpenGL/ES.
-*/
-
-/*!
- \enum QGLBuffer::Access
- This enum defines the access mode for QGLBuffer::map().
-
- \value ReadOnly The buffer will be mapped for reading only.
- \value WriteOnly The buffer will be mapped for writing only.
- \value ReadWrite The buffer will be mapped for reading and writing.
-*/
-
-class QGLBufferPrivate
-{
-public:
- QGLBufferPrivate(QGLBuffer::Type t)
- : ref(1),
- type(t),
- guard(0),
- usagePattern(QGLBuffer::StaticDraw),
- actualUsagePattern(QGLBuffer::StaticDraw),
- funcs(0)
- {
- }
-
- QAtomicInt ref;
- QGLBuffer::Type type;
- QGLSharedResourceGuardBase *guard;
- QGLBuffer::UsagePattern usagePattern;
- QGLBuffer::UsagePattern actualUsagePattern;
- QOpenGLExtensions *funcs;
-};
-
-/*!
- Constructs a new buffer object of type QGLBuffer::VertexBuffer.
-
- Note: this constructor just creates the QGLBuffer instance. The actual
- buffer object in the GL server is not created until create() is called.
-
- \sa create()
-*/
-QGLBuffer::QGLBuffer()
- : d_ptr(new QGLBufferPrivate(QGLBuffer::VertexBuffer))
-{
-}
-
-/*!
- Constructs a new buffer object of \a type.
-
- Note: this constructor just creates the QGLBuffer instance. The actual
- buffer object in the GL server is not created until create() is called.
-
- \sa create()
-*/
-QGLBuffer::QGLBuffer(QGLBuffer::Type type)
- : d_ptr(new QGLBufferPrivate(type))
-{
-}
-
-/*!
- Constructs a shallow copy of \a other.
-
- Note: QGLBuffer does not implement copy-on-write semantics,
- so \a other will be affected whenever the copy is modified.
-*/
-QGLBuffer::QGLBuffer(const QGLBuffer &other)
- : d_ptr(other.d_ptr)
-{
- d_ptr->ref.ref();
-}
-
-#define ctx QGLContext::currentContext();
-
-/*!
- Destroys this buffer object, including the storage being
- used in the GL server.
-*/
-QGLBuffer::~QGLBuffer()
-{
- if (!d_ptr->ref.deref()) {
- destroy();
- delete d_ptr;
- }
-}
-
-/*!
- Assigns a shallow copy of \a other to this object.
-
- Note: QGLBuffer does not implement copy-on-write semantics,
- so \a other will be affected whenever the copy is modified.
-*/
-QGLBuffer &QGLBuffer::operator=(const QGLBuffer &other)
-{
- if (d_ptr != other.d_ptr) {
- other.d_ptr->ref.ref();
- if (!d_ptr->ref.deref()) {
- destroy();
- delete d_ptr;
- }
- d_ptr = other.d_ptr;
- }
- return *this;
-}
-
-/*!
- Returns the type of buffer represented by this object.
-*/
-QGLBuffer::Type QGLBuffer::type() const
-{
- Q_D(const QGLBuffer);
- return d->type;
-}
-
-/*!
- Returns the usage pattern for this buffer object.
- The default value is StaticDraw.
-
- \sa setUsagePattern()
-*/
-QGLBuffer::UsagePattern QGLBuffer::usagePattern() const
-{
- Q_D(const QGLBuffer);
- return d->usagePattern;
-}
-
-/*!
- Sets the usage pattern for this buffer object to \a value.
- This function must be called before allocate() or write().
-
- \sa usagePattern(), allocate(), write()
-*/
-void QGLBuffer::setUsagePattern(QGLBuffer::UsagePattern value)
-{
- Q_D(QGLBuffer);
- d->usagePattern = d->actualUsagePattern = value;
-}
-
-#undef ctx
-
-namespace {
- void freeBufferFunc(QGLContext *ctx, GLuint id)
- {
- Q_ASSERT(ctx);
- ctx->contextHandle()->functions()->glDeleteBuffers(1, &id);
- }
-}
-
-/*!
- Creates the buffer object in the GL server. Returns \c true if
- the object was created; false otherwise.
-
- This function must be called with a current QGLContext.
- The buffer will be bound to and can only be used in
- that context (or any other context that is shared with it).
-
- This function will return false if the GL implementation
- does not support buffers, or there is no current QGLContext.
-
- \sa isCreated(), allocate(), write(), destroy()
-*/
-bool QGLBuffer::create()
-{
- Q_D(QGLBuffer);
- if (d->guard && d->guard->id())
- return true;
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
- if (ctx) {
- delete d->funcs;
- d->funcs = new QOpenGLExtensions(ctx->contextHandle());
- if (!d->funcs->hasOpenGLFeature(QOpenGLFunctions::Buffers))
- return false;
-
- GLuint bufferId = 0;
- d->funcs->glGenBuffers(1, &bufferId);
- if (bufferId) {
- if (d->guard)
- d->guard->free();
-
- d->guard = createSharedResourceGuard(ctx, bufferId, freeBufferFunc);
- return true;
- }
- }
- return false;
-}
-
-#define ctx QGLContext::currentContext()
-
-/*!
- Returns \c true if this buffer has been created; false otherwise.
-
- \sa create(), destroy()
-*/
-bool QGLBuffer::isCreated() const
-{
- Q_D(const QGLBuffer);
- return d->guard && d->guard->id();
-}
-
-/*!
- Destroys this buffer object, including the storage being
- used in the GL server. All references to the buffer will
- become invalid.
-*/
-void QGLBuffer::destroy()
-{
- Q_D(QGLBuffer);
- if (d->guard) {
- d->guard->free();
- d->guard = 0;
- }
-}
-
-/*!
- Reads the \a count bytes in this buffer starting at \a offset
- into \a data. Returns \c true on success; false if reading from
- the buffer is not supported. Buffer reading is not supported
- under OpenGL/ES.
-
- It is assumed that this buffer has been bound to the current context.
-
- \sa write(), bind()
-*/
-bool QGLBuffer::read(int offset, void *data, int count)
-{
-#if !defined(QT_OPENGL_ES)
- Q_D(QGLBuffer);
- if (!d->funcs->hasOpenGLFeature(QOpenGLFunctions::Buffers) || !d->guard->id() || !d->funcs->d()->GetBufferSubData)
- return false;
- while (d->funcs->glGetError() != GL_NO_ERROR) ; // Clear error state.
- d->funcs->glGetBufferSubData(d->type, offset, count, data);
- return d->funcs->glGetError() == GL_NO_ERROR;
-#else
- Q_UNUSED(offset);
- Q_UNUSED(data);
- Q_UNUSED(count);
- return false;
-#endif
-}
-
-/*!
- Replaces the \a count bytes of this buffer starting at \a offset
- with the contents of \a data. Any other bytes in the buffer
- will be left unmodified.
-
- It is assumed that create() has been called on this buffer and that
- it has been bound to the current context.
-
- \sa create(), read(), allocate()
-*/
-void QGLBuffer::write(int offset, const void *data, int count)
-{
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::allocate(): buffer not created");
-#endif
- Q_D(QGLBuffer);
- if (d->guard && d->guard->id())
- d->funcs->glBufferSubData(d->type, offset, count, data);
-}
-
-/*!
- Allocates \a count bytes of space to the buffer, initialized to
- the contents of \a data. Any previous contents will be removed.
-
- It is assumed that create() has been called on this buffer and that
- it has been bound to the current context.
-
- \sa create(), read(), write()
-*/
-void QGLBuffer::allocate(const void *data, int count)
-{
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::allocate(): buffer not created");
-#endif
- Q_D(QGLBuffer);
- if (d->guard && d->guard->id())
- d->funcs->glBufferData(d->type, count, data, d->actualUsagePattern);
-}
-
-/*!
- \fn void QGLBuffer::allocate(int count)
- \overload
-
- Allocates \a count bytes of space to the buffer. Any previous
- contents will be removed.
-
- It is assumed that create() has been called on this buffer and that
- it has been bound to the current context.
-
- \sa create(), write()
-*/
-
-/*!
- Binds the buffer associated with this object to the current
- GL context. Returns \c false if binding was not possible, usually because
- type() is not supported on this GL implementation.
-
- The buffer must be bound to the same QGLContext current when create()
- was called, or to another QGLContext that is sharing with it.
- Otherwise, false will be returned from this function.
-
- \sa release(), create()
-*/
-bool QGLBuffer::bind()
-{
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::bind(): buffer not created");
-#endif
- Q_D(const QGLBuffer);
- GLuint bufferId = d->guard ? d->guard->id() : 0;
- if (bufferId) {
- if (d->guard->group() != QOpenGLContextGroup::currentContextGroup()) {
-#ifndef QT_NO_DEBUG
- qWarning("QGLBuffer::bind: buffer is not valid in the current context");
-#endif
- return false;
- }
- d->funcs->glBindBuffer(d->type, bufferId);
- return true;
- } else {
- return false;
- }
-}
-
-/*!
- Releases the buffer associated with this object from the
- current GL context.
-
- This function must be called with the same QGLContext current
- as when bind() was called on the buffer.
-
- \sa bind()
-*/
-void QGLBuffer::release()
-{
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::release(): buffer not created");
-#endif
- Q_D(const QGLBuffer);
- if (d->guard && d->guard->id())
- d->funcs->glBindBuffer(d->type, 0);
-}
-
-#undef ctx
-
-/*!
- Releases the buffer associated with \a type in the current
- QGLContext.
-
- This function is a direct call to \c{glBindBuffer(type, 0)}
- for use when the caller does not know which QGLBuffer has
- been bound to the context but wants to make sure that it
- is released.
-
- \snippet code/src_opengl_qglbuffer.cpp 1
-*/
-void QGLBuffer::release(QGLBuffer::Type type)
-{
- if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
- ctx->functions()->glBindBuffer(GLenum(type), 0);
-}
-
-#define ctx QGLContext::currentContext()
-
-/*!
- Returns the GL identifier associated with this buffer; zero if
- the buffer has not been created.
-
- \sa isCreated()
-*/
-GLuint QGLBuffer::bufferId() const
-{
- Q_D(const QGLBuffer);
- return d->guard ? d->guard->id() : 0;
-}
-
-#ifndef GL_BUFFER_SIZE
-#define GL_BUFFER_SIZE 0x8764
-#endif
-
-/*!
- Returns the size of the data in this buffer, for reading operations.
- Returns -1 if fetching the buffer size is not supported, or the
- buffer has not been created.
-
- It is assumed that this buffer has been bound to the current context.
-
- \sa isCreated(), bind()
-*/
-int QGLBuffer::size() const
-{
- Q_D(const QGLBuffer);
- if (!d->guard || !d->guard->id())
- return -1;
- GLint value = -1;
- d->funcs->glGetBufferParameteriv(d->type, GL_BUFFER_SIZE, &value);
- return value;
-}
-
-/*!
- Maps the contents of this buffer into the application's memory
- space and returns a pointer to it. Returns null if memory
- mapping is not possible. The \a access parameter indicates the
- type of access to be performed.
-
- It is assumed that create() has been called on this buffer and that
- it has been bound to the current context.
-
- This function is only supported under OpenGL/ES if the
- \c{GL_OES_mapbuffer} extension is present.
-
- \sa unmap(), create(), bind()
-*/
-void *QGLBuffer::map(QGLBuffer::Access access)
-{
- Q_D(QGLBuffer);
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::map(): buffer not created");
-#endif
- if (!d->guard || !d->guard->id())
- return 0;
- return d->funcs->glMapBuffer(d->type, access);
-}
-
-/*!
- Unmaps the buffer after it was mapped into the application's
- memory space with a previous call to map(). Returns \c true if
- the unmap succeeded; false otherwise.
-
- It is assumed that this buffer has been bound to the current context,
- and that it was previously mapped with map().
-
- This function is only supported under OpenGL/ES if the
- \c{GL_OES_mapbuffer} extension is present.
-
- \sa map()
-*/
-bool QGLBuffer::unmap()
-{
- Q_D(QGLBuffer);
-#ifndef QT_NO_DEBUG
- if (!isCreated())
- qWarning("QGLBuffer::unmap(): buffer not created");
-#endif
- if (!d->guard || !d->guard->id())
- return false;
- return d->funcs->glUnmapBuffer(d->type) == GL_TRUE;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/qglbuffer.h b/src/opengl/qglbuffer.h
deleted file mode 100644
index daf5227c66..0000000000
--- a/src/opengl/qglbuffer.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGLBUFFER_H
-#define QGLBUFFER_H
-
-#include <QtCore/qscopedpointer.h>
-#include <QtOpenGL/qgl.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class QGLBufferPrivate;
-
-class Q_OPENGL_EXPORT QGLBuffer
-{
-public:
- enum Type
- {
- VertexBuffer = 0x8892, // GL_ARRAY_BUFFER
- IndexBuffer = 0x8893, // GL_ELEMENT_ARRAY_BUFFER
- PixelPackBuffer = 0x88EB, // GL_PIXEL_PACK_BUFFER
- PixelUnpackBuffer = 0x88EC // GL_PIXEL_UNPACK_BUFFER
- };
-
- QGLBuffer();
- explicit QGLBuffer(QGLBuffer::Type type);
- QGLBuffer(const QGLBuffer &other);
- ~QGLBuffer();
-
- QGLBuffer &operator=(const QGLBuffer &other);
-
- enum UsagePattern
- {
- StreamDraw = 0x88E0, // GL_STREAM_DRAW
- StreamRead = 0x88E1, // GL_STREAM_READ
- StreamCopy = 0x88E2, // GL_STREAM_COPY
- StaticDraw = 0x88E4, // GL_STATIC_DRAW
- StaticRead = 0x88E5, // GL_STATIC_READ
- StaticCopy = 0x88E6, // GL_STATIC_COPY
- DynamicDraw = 0x88E8, // GL_DYNAMIC_DRAW
- DynamicRead = 0x88E9, // GL_DYNAMIC_READ
- DynamicCopy = 0x88EA // GL_DYNAMIC_COPY
- };
-
- enum Access
- {
- ReadOnly = 0x88B8, // GL_READ_ONLY
- WriteOnly = 0x88B9, // GL_WRITE_ONLY
- ReadWrite = 0x88BA // GL_READ_WRITE
- };
-
- QGLBuffer::Type type() const;
-
- QGLBuffer::UsagePattern usagePattern() const;
- void setUsagePattern(QGLBuffer::UsagePattern value);
-
- bool create();
- bool isCreated() const;
-
- void destroy();
-
- bool bind();
- void release();
-
- static void release(QGLBuffer::Type type);
-
- GLuint bufferId() const;
-
- int size() const;
-
- bool read(int offset, void *data, int count);
- void write(int offset, const void *data, int count);
-
- void allocate(const void *data, int count);
- inline void allocate(int count) { allocate(nullptr, count); }
-
- void *map(QGLBuffer::Access access);
- bool unmap();
-
-private:
- QGLBufferPrivate *d_ptr;
-
- Q_DECLARE_PRIVATE(QGLBuffer)
-};
-
-QT_END_NAMESPACE
-
-#endif
diff --git a/src/opengl/qglcolormap.cpp b/src/opengl/qglcolormap.cpp
deleted file mode 100644
index f314a9715d..0000000000
--- a/src/opengl/qglcolormap.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-/*!
- \class QGLColormap
- \brief The QGLColormap class is used for installing custom colormaps into
- a QGLWidget.
-
- \obsolete
- \inmodule QtOpenGL
- \ingroup painting-3D
- \ingroup shared
-
- QGLColormap provides a platform independent way of specifying and
- installing indexed colormaps for a QGLWidget. QGLColormap is
- especially useful when using the OpenGL color-index mode.
-
- Under X11 you must use an X server that supports either a \c
- PseudoColor or \c DirectColor visual class. If your X server
- currently only provides a \c GrayScale, \c TrueColor, \c
- StaticColor or \c StaticGray visual, you will not be able to
- allocate colorcells for writing. If this is the case, try setting
- your X server to 8 bit mode. It should then provide you with at
- least a \c PseudoColor visual. Note that you may experience
- colormap flashing if your X server is running in 8 bit mode.
-
- The size() of the colormap is always set to 256
- colors. Note that under Windows you can also install colormaps
- in child widgets.
-
- This class uses \l{implicit sharing} as a memory and speed
- optimization.
-
- Example of use:
- \snippet code/src_opengl_qglcolormap.cpp 0
-
- \sa QGLWidget::setColormap(), QGLWidget::colormap()
-*/
-
-/*!
- \fn Qt::HANDLE QGLColormap::handle()
-
- \internal
-
- Returns the handle for this color map.
-*/
-
-/*!
- \fn void QGLColormap::setHandle(Qt::HANDLE handle)
-
- \internal
-
- Sets the handle for this color map to \a handle.
-*/
-
-#include "qglcolormap.h"
-
-QT_BEGIN_NAMESPACE
-
-QGLColormap::QGLColormapData QGLColormap::shared_null = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0 };
-
-/*!
- Construct a QGLColormap.
-*/
-QGLColormap::QGLColormap()
- : d(&shared_null)
-{
- d->ref.ref();
-}
-
-
-/*!
- Construct a shallow copy of \a map.
-*/
-QGLColormap::QGLColormap(const QGLColormap &map)
- : d(map.d)
-{
- d->ref.ref();
-}
-
-/*!
- Dereferences the QGLColormap and deletes it if this was the last
- reference to it.
-*/
-QGLColormap::~QGLColormap()
-{
- if (!d->ref.deref())
- cleanup(d);
-}
-
-void QGLColormap::cleanup(QGLColormap::QGLColormapData *x)
-{
- delete x->cells;
- x->cells = 0;
- delete x;
-}
-
-/*!
- Assign a shallow copy of \a map to this QGLColormap.
-*/
-QGLColormap & QGLColormap::operator=(const QGLColormap &map)
-{
- map.d->ref.ref();
- if (!d->ref.deref())
- cleanup(d);
- d = map.d;
- return *this;
-}
-
-/*!
- \fn void QGLColormap::detach()
- \internal
-
- Detaches this QGLColormap from the shared block.
-*/
-
-void QGLColormap::detach_helper()
-{
- QGLColormapData *x = new QGLColormapData;
- x->ref.storeRelaxed(1);
- x->cmapHandle = 0;
- x->cells = 0;
- if (d->cells) {
- x->cells = new QVector<QRgb>(256);
- *x->cells = *d->cells;
- }
- if (!d->ref.deref())
- cleanup(d);
- d = x;
-}
-
-/*!
- Set cell at index \a idx in the colormap to color \a color.
-*/
-void QGLColormap::setEntry(int idx, QRgb color)
-{
- detach();
- if (!d->cells)
- d->cells = new QVector<QRgb>(256);
- d->cells->replace(idx, color);
-}
-
-/*!
- Set an array of cells in this colormap. \a count is the number of
- colors that should be set, \a colors is the array of colors, and
- \a base is the starting index. The first element in \a colors
- is set at \a base in the colormap.
-*/
-void QGLColormap::setEntries(int count, const QRgb *colors, int base)
-{
- detach();
- if (!d->cells)
- d->cells = new QVector<QRgb>(256);
-
- Q_ASSERT_X(colors && base >= 0 && (base + count) <= d->cells->size(), "QGLColormap::setEntries",
- "preconditions not met");
- for (int i = 0; i < count; ++i)
- setEntry(base + i, colors[i]);
-}
-
-/*!
- Returns the QRgb value in the colorcell with index \a idx.
-*/
-QRgb QGLColormap::entryRgb(int idx) const
-{
- if (d == &shared_null || !d->cells)
- return 0;
- else
- return d->cells->at(idx);
-}
-
-/*!
- \overload
-
- Set the cell with index \a idx in the colormap to color \a color.
-*/
-void QGLColormap::setEntry(int idx, const QColor &color)
-{
- setEntry(idx, color.rgb());
-}
-
-/*!
- Returns the QRgb value in the colorcell with index \a idx.
-*/
-QColor QGLColormap::entryColor(int idx) const
-{
- if (d == &shared_null || !d->cells)
- return QColor();
- else
- return QColor(d->cells->at(idx));
-}
-
-/*!
- Returns \c true if the colormap is empty or it is not in use
- by a QGLWidget; otherwise returns \c false.
-
- A colormap with no color values set is considered to be empty.
- For historical reasons, a colormap that has color values set
- but which is not in use by a QGLWidget is also considered empty.
-
- Compare size() with zero to determine if the colormap is empty
- regardless of whether it is in use by a QGLWidget or not.
-
- \sa size()
-*/
-bool QGLColormap::isEmpty() const
-{
- return d == &shared_null || d->cells == 0 || d->cells->size() == 0 || d->cmapHandle == 0;
-}
-
-
-/*!
- Returns the number of colorcells in the colormap.
-*/
-int QGLColormap::size() const
-{
- return d->cells ? d->cells->size() : 0;
-}
-
-/*!
- Returns the index of the color \a color. If \a color is not in the
- map, -1 is returned.
-*/
-int QGLColormap::find(QRgb color) const
-{
- if (d->cells)
- return d->cells->indexOf(color);
- return -1;
-}
-
-/*!
- Returns the index of the color that is the closest match to color
- \a color.
-*/
-int QGLColormap::findNearest(QRgb color) const
-{
- int idx = find(color);
- if (idx >= 0)
- return idx;
- int mapSize = size();
- int mindist = 200000;
- int r = qRed(color);
- int g = qGreen(color);
- int b = qBlue(color);
- int rx, gx, bx, dist;
- for (int i = 0; i < mapSize; ++i) {
- QRgb ci = d->cells->at(i);
- rx = r - qRed(ci);
- gx = g - qGreen(ci);
- bx = b - qBlue(ci);
- dist = rx * rx + gx * gx + bx * bx; // calculate distance
- if (dist < mindist) { // minimal?
- mindist = dist;
- idx = i;
- }
- }
- return idx;
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/qglcolormap.h b/src/opengl/qglcolormap.h
deleted file mode 100644
index b59b56e040..0000000000
--- a/src/opengl/qglcolormap.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGLCOLORMAP_H
-#define QGLCOLORMAP_H
-
-#include <QtGui/qcolor.h>
-#include <QtCore/qvector.h>
-#include <QtOpenGL/qtopenglglobal.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class Q_OPENGL_EXPORT QGLColormap
-{
-public:
- QGLColormap();
- QGLColormap(const QGLColormap &);
- ~QGLColormap();
-
- QGLColormap &operator=(const QGLColormap &);
-
- bool isEmpty() const;
- int size() const;
- void detach();
-
- void setEntries(int count, const QRgb * colors, int base = 0);
- void setEntry(int idx, QRgb color);
- void setEntry(int idx, const QColor & color);
- QRgb entryRgb(int idx) const;
- QColor entryColor(int idx) const;
- int find(QRgb color) const;
- int findNearest(QRgb color) const;
-
-protected:
- Qt::HANDLE handle() { return d ? d->cmapHandle : nullptr; }
- void setHandle(Qt::HANDLE ahandle) { d->cmapHandle = ahandle; }
-
-private:
- struct QGLColormapData {
- QBasicAtomicInt ref;
- QVector<QRgb> *cells;
- Qt::HANDLE cmapHandle;
- };
-
- QGLColormapData *d;
- static struct QGLColormapData shared_null;
- static void cleanup(QGLColormapData *x);
- void detach_helper();
-
- friend class QGLWidget;
- friend class QGLWidgetPrivate;
-};
-
-inline void QGLColormap::detach()
-{
- if (d->ref.loadRelaxed() != 1)
- detach_helper();
-}
-
-QT_END_NAMESPACE
-
-#endif // QGLCOLORMAP_H
diff --git a/src/opengl/qglframebufferobject.cpp b/src/opengl/qglframebufferobject.cpp
deleted file mode 100644
index d0f82a85fa..0000000000
--- a/src/opengl/qglframebufferobject.cpp
+++ /dev/null
@@ -1,1466 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qglframebufferobject.h"
-#include "qglframebufferobject_p.h"
-
-#include <qdebug.h>
-#include <private/qgl_p.h>
-#include <private/qfont_p.h>
-#include "gl2paintengineex/qpaintengineex_opengl2_p.h"
-
-#include <qimage.h>
-#include <qwindow.h>
-
-QT_BEGIN_NAMESPACE
-
-extern QImage qt_gl_read_frame_buffer(const QSize&, bool, bool);
-
-#define QGL_FUNC_CONTEXT const QGLContext *ctx = QGLContext::currentContext();
-#define QGL_FUNCP_CONTEXT const QGLContext *ctx = QGLContext::currentContext();
-
-#ifndef QT_NO_DEBUG
-#define QT_RESET_GLERROR() \
-{ \
- while (QOpenGLContext::currentContext()->functions()->glGetError() != GL_NO_ERROR) {} \
-}
-#define QT_CHECK_GLERROR() \
-{ \
- GLenum err = QOpenGLContext::currentContext()->functions()->glGetError(); \
- if (err != GL_NO_ERROR) { \
- qDebug("[%s line %d] GL Error: %d", \
- __FILE__, __LINE__, (int)err); \
- } \
-}
-#else
-#define QT_RESET_GLERROR() {}
-#define QT_CHECK_GLERROR() {}
-#endif
-
-// ####TODO Properly #ifdef this class to use #define symbols actually defined
-// by OpenGL/ES includes
-#ifndef GL_MAX_SAMPLES
-#define GL_MAX_SAMPLES 0x8D57
-#endif
-
-#ifndef GL_RENDERBUFFER_SAMPLES
-#define GL_RENDERBUFFER_SAMPLES 0x8CAB
-#endif
-
-#ifndef GL_DEPTH24_STENCIL8
-#define GL_DEPTH24_STENCIL8 0x88F0
-#endif
-
-#ifndef GL_DEPTH_COMPONENT24
-#define GL_DEPTH_COMPONENT24 0x81A6
-#endif
-
-#ifndef GL_DEPTH_COMPONENT24_OES
-#define GL_DEPTH_COMPONENT24_OES 0x81A6
-#endif
-
-#ifndef GL_READ_FRAMEBUFFER
-#define GL_READ_FRAMEBUFFER 0x8CA8
-#endif
-
-#ifndef GL_DRAW_FRAMEBUFFER
-#define GL_DRAW_FRAMEBUFFER 0x8CA9
-#endif
-
-#ifndef GL_DEPTH_STENCIL_ATTACHMENT
-#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
-#endif
-
-#ifndef GL_DEPTH_STENCIL
-#define GL_DEPTH_STENCIL 0x84F9
-#endif
-
-/*!
- \class QGLFramebufferObjectFormat
- \inmodule QtOpenGL
- \brief The QGLFramebufferObjectFormat class specifies the format of an OpenGL
- framebuffer object.
-
- \since 4.6
- \obsolete
-
- \ingroup painting-3D
-
- A framebuffer object has several characteristics:
- \list
- \li \l{setSamples()}{Number of samples per pixels.}
- \li \l{setAttachment()}{Depth and/or stencil attachments.}
- \li \l{setTextureTarget()}{Texture target.}
- \li \l{setInternalTextureFormat()}{Internal texture format.}
- \endlist
-
- Note that the desired attachments or number of samples per pixels might not
- be supported by the hardware driver. Call QGLFramebufferObject::format()
- after creating a QGLFramebufferObject to find the exact format that was
- used to create the frame buffer object.
-
- \note This class has been deprecated in favor of QOpenGLFramebufferObjectFormat.
-
- \sa QGLFramebufferObject
-*/
-
-/*!
- \internal
-*/
-void QGLFramebufferObjectFormat::detach()
-{
- if (d->ref.loadRelaxed() != 1) {
- QGLFramebufferObjectFormatPrivate *newd
- = new QGLFramebufferObjectFormatPrivate(d);
- if (!d->ref.deref())
- delete d;
- d = newd;
- }
-}
-
-/*!
- Creates a QGLFramebufferObjectFormat object for specifying
- the format of an OpenGL framebuffer object.
-
- By default the format specifies a non-multisample framebuffer object with no
- attachments, texture target \c GL_TEXTURE_2D, and internal format \c GL_RGBA8.
- On OpenGL/ES systems, the default internal format is \c GL_RGBA.
-
- \sa samples(), attachment(), internalTextureFormat()
-*/
-
-QGLFramebufferObjectFormat::QGLFramebufferObjectFormat()
-{
- d = new QGLFramebufferObjectFormatPrivate;
-}
-
-/*!
- Constructs a copy of \a other.
-*/
-
-QGLFramebufferObjectFormat::QGLFramebufferObjectFormat(const QGLFramebufferObjectFormat &other)
-{
- d = other.d;
- d->ref.ref();
-}
-
-/*!
- Assigns \a other to this object.
-*/
-
-QGLFramebufferObjectFormat &QGLFramebufferObjectFormat::operator=(const QGLFramebufferObjectFormat &other)
-{
- if (d != other.d) {
- other.d->ref.ref();
- if (!d->ref.deref())
- delete d;
- d = other.d;
- }
- return *this;
-}
-
-/*!
- Destroys the QGLFramebufferObjectFormat.
-*/
-QGLFramebufferObjectFormat::~QGLFramebufferObjectFormat()
-{
- if (!d->ref.deref())
- delete d;
-}
-
-/*!
- Sets the number of samples per pixel for a multisample framebuffer object
- to \a samples. The default sample count of 0 represents a regular
- non-multisample framebuffer object.
-
- If the desired amount of samples per pixel is not supported by the hardware
- then the maximum number of samples per pixel will be used. Note that
- multisample framebuffer objects cannot be bound as textures. Also, the
- \c{GL_EXT_framebuffer_multisample} extension is required to create a
- framebuffer with more than one sample per pixel.
-
- \sa samples()
-*/
-void QGLFramebufferObjectFormat::setSamples(int samples)
-{
- detach();
- d->samples = samples;
-}
-
-/*!
- Returns the number of samples per pixel if a framebuffer object
- is a multisample framebuffer object. Otherwise, returns 0.
- The default value is 0.
-
- \sa setSamples()
-*/
-int QGLFramebufferObjectFormat::samples() const
-{
- return d->samples;
-}
-
-/*!
- \since 4.8
-
- Enables mipmapping if \a enabled is true; otherwise disables it.
-
- Mipmapping is disabled by default.
-
- If mipmapping is enabled, additional memory will be allocated for
- the mipmap levels. The mipmap levels can be updated by binding the
- texture and calling glGenerateMipmap(). Mipmapping cannot be enabled
- for multisampled framebuffer objects.
-
- \sa mipmap(), QGLFramebufferObject::texture()
-*/
-void QGLFramebufferObjectFormat::setMipmap(bool enabled)
-{
- detach();
- d->mipmap = enabled;
-}
-
-/*!
- \since 4.8
-
- Returns \c true if mipmapping is enabled.
-
- \sa setMipmap()
-*/
-bool QGLFramebufferObjectFormat::mipmap() const
-{
- return d->mipmap;
-}
-
-/*!
- Sets the attachment configuration of a framebuffer object to \a attachment.
-
- \sa attachment()
-*/
-void QGLFramebufferObjectFormat::setAttachment(QGLFramebufferObject::Attachment attachment)
-{
- detach();
- d->attachment = attachment;
-}
-
-/*!
- Returns the configuration of the depth and stencil buffers attached to
- a framebuffer object. The default is QGLFramebufferObject::NoAttachment.
-
- \sa setAttachment()
-*/
-QGLFramebufferObject::Attachment QGLFramebufferObjectFormat::attachment() const
-{
- return d->attachment;
-}
-
-/*!
- Sets the texture target of the texture attached to a framebuffer object to
- \a target. Ignored for multisample framebuffer objects.
-
- \sa textureTarget(), samples()
-*/
-void QGLFramebufferObjectFormat::setTextureTarget(GLenum target)
-{
- detach();
- d->target = target;
-}
-
-/*!
- Returns the texture target of the texture attached to a framebuffer object.
- Ignored for multisample framebuffer objects. The default is
- \c GL_TEXTURE_2D.
-
- \sa setTextureTarget(), samples()
-*/
-GLenum QGLFramebufferObjectFormat::textureTarget() const
-{
- return d->target;
-}
-
-/*!
- Sets the internal format of a framebuffer object's texture or
- multisample framebuffer object's color buffer to
- \a internalTextureFormat.
-
- \sa internalTextureFormat()
-*/
-void QGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat)
-{
- detach();
- d->internal_format = internalTextureFormat;
-}
-
-/*!
- Returns the internal format of a framebuffer object's texture or
- multisample framebuffer object's color buffer. The default is
- \c GL_RGBA8 on desktop OpenGL systems, and \c GL_RGBA on
- OpenGL/ES systems.
-
- \sa setInternalTextureFormat()
-*/
-GLenum QGLFramebufferObjectFormat::internalTextureFormat() const
-{
- return d->internal_format;
-}
-
-/*!
- Returns \c true if all the options of this framebuffer object format
- are the same as \a other; otherwise returns \c false.
-*/
-bool QGLFramebufferObjectFormat::operator==(const QGLFramebufferObjectFormat& other) const
-{
- if (d == other.d)
- return true;
- else
- return d->equals(other.d);
-}
-
-/*!
- Returns \c false if all the options of this framebuffer object format
- are the same as \a other; otherwise returns \c true.
-*/
-bool QGLFramebufferObjectFormat::operator!=(const QGLFramebufferObjectFormat& other) const
-{
- return !(*this == other);
-}
-
-void QGLFBOGLPaintDevice::setFBO(QGLFramebufferObject* f,
- QGLFramebufferObject::Attachment attachment)
-{
- fbo = f;
- m_thisFBO = fbo->d_func()->fbo(); // This shouldn't be needed
-
- // The context that the fbo was created in may not have depth
- // and stencil buffers, but the fbo itself might.
- fboFormat = QGLContext::currentContext()->format();
- if (attachment == QGLFramebufferObject::CombinedDepthStencil) {
- fboFormat.setDepth(true);
- fboFormat.setStencil(true);
- } else if (attachment == QGLFramebufferObject::Depth) {
- fboFormat.setDepth(true);
- fboFormat.setStencil(false);
- } else {
- fboFormat.setDepth(false);
- fboFormat.setStencil(false);
- }
-
- GLenum format = f->format().internalTextureFormat();
- reqAlpha = (format != GL_RGB
-#ifdef GL_RGB5
- && format != GL_RGB5
-#endif
-#ifdef GL_RGB8
- && format != GL_RGB8
-#endif
- );
-}
-
-QGLContext *QGLFBOGLPaintDevice::context() const
-{
- return const_cast<QGLContext *>(QGLContext::currentContext());
-}
-
-bool QGLFramebufferObjectPrivate::checkFramebufferStatus() const
-{
- QGL_FUNCP_CONTEXT;
- if (!ctx)
- return false; // Context no longer exists.
- GLenum status = ctx->contextHandle()->functions()->glCheckFramebufferStatus(GL_FRAMEBUFFER);
- switch(status) {
- case GL_NO_ERROR:
- case GL_FRAMEBUFFER_COMPLETE:
- return true;
- case GL_FRAMEBUFFER_UNSUPPORTED:
- qDebug("QGLFramebufferObject: Unsupported framebuffer format.");
- break;
- case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
- qDebug("QGLFramebufferObject: Framebuffer incomplete attachment.");
- break;
- case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, missing attachment.");
- break;
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT
- case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, duplicate attachment.");
- break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
- case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, attached images must have same dimensions.");
- break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_FORMATS
- case GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, attached images must have same format.");
- break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
- case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, missing draw buffer.");
- break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
- case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, missing read buffer.");
- break;
-#endif
-#ifdef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
- case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
- qDebug("QGLFramebufferObject: Framebuffer incomplete, attachments must have same number of samples per pixel.");
- break;
-#endif
- default:
- qDebug() <<"QGLFramebufferObject: An undefined error has occurred: "<< status;
- break;
- }
- return false;
-}
-
-namespace
-{
- void freeFramebufferFunc(QGLContext *ctx, GLuint id)
- {
- Q_ASSERT(ctx);
- ctx->contextHandle()->functions()->glDeleteFramebuffers(1, &id);
- }
-
- void freeRenderbufferFunc(QGLContext *ctx, GLuint id)
- {
- Q_ASSERT(ctx);
- ctx->contextHandle()->functions()->glDeleteRenderbuffers(1, &id);
- }
-
- void freeTextureFunc(QGLContext *ctx, GLuint id)
- {
- Q_UNUSED(ctx);
- ctx->contextHandle()->functions()->glDeleteTextures(1, &id);
- }
-}
-
-void QGLFramebufferObjectPrivate::init(QGLFramebufferObject *q, const QSize &sz,
- QGLFramebufferObject::Attachment attachment,
- GLenum texture_target, GLenum internal_format,
- GLint samples, bool mipmap)
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
-
- funcs.initializeOpenGLFunctions();
-
- if (!funcs.hasOpenGLFeature(QOpenGLFunctions::Framebuffers))
- return;
-
- ctx->d_ptr->refreshCurrentFbo();
-
- size = sz;
- target = texture_target;
- // texture dimensions
-
- QT_RESET_GLERROR(); // reset error state
- GLuint fbo = 0;
- funcs.glGenFramebuffers(1, &fbo);
- funcs.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-
- GLuint texture = 0;
- GLuint color_buffer = 0;
- GLuint depth_buffer = 0;
- GLuint stencil_buffer = 0;
-
- QT_CHECK_GLERROR();
- // init texture
- if (samples == 0) {
- funcs.glGenTextures(1, &texture);
- funcs.glBindTexture(target, texture);
- funcs.glTexImage2D(target, 0, internal_format, size.width(), size.height(), 0,
- GL_RGBA, GL_UNSIGNED_BYTE, NULL);
- if (mipmap) {
- int width = size.width();
- int height = size.height();
- int level = 0;
- while (width > 1 || height > 1) {
- width = qMax(1, width >> 1);
- height = qMax(1, height >> 1);
- ++level;
- funcs.glTexImage2D(target, level, internal_format, width, height, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, NULL);
- }
- }
- funcs.glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- funcs.glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- funcs.glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- funcs.glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- funcs.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- target, texture, 0);
-
- QT_CHECK_GLERROR();
- valid = checkFramebufferStatus();
- funcs.glBindTexture(target, 0);
-
- color_buffer = 0;
- } else {
- mipmap = false;
- GLint maxSamples;
- funcs.glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
-
- samples = qBound(0, int(samples), int(maxSamples));
-
- funcs.glGenRenderbuffers(1, &color_buffer);
- funcs.glBindRenderbuffer(GL_RENDERBUFFER, color_buffer);
- if (funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample) && samples > 0) {
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- internal_format, size.width(), size.height());
- } else {
- samples = 0;
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, internal_format,
- size.width(), size.height());
- }
-
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_RENDERBUFFER, color_buffer);
-
- QT_CHECK_GLERROR();
- valid = checkFramebufferStatus();
-
- if (valid)
- funcs.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
- }
-
- // In practice, a combined depth-stencil buffer is supported by all desktop platforms, while a
- // separate stencil buffer is not. On embedded devices however, a combined depth-stencil buffer
- // might not be supported while separate buffers are, according to QTBUG-12861.
-
- if (attachment == QGLFramebufferObject::CombinedDepthStencil
- && funcs.hasOpenGLExtension(QOpenGLExtensions::PackedDepthStencil)) {
- // depth and stencil buffer needs another extension
- funcs.glGenRenderbuffers(1, &depth_buffer);
- funcs.glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
- Q_ASSERT(funcs.glIsRenderbuffer(depth_buffer));
-#ifndef Q_OS_WASM
- if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample))
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH24_STENCIL8, size.width(), size.height());
- else
- funcs.glRenderbufferStorage(GL_RENDERBUFFER,
- GL_DEPTH24_STENCIL8, size.width(), size.height());
-
- stencil_buffer = depth_buffer;
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_RENDERBUFFER, depth_buffer);
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
- GL_RENDERBUFFER, stencil_buffer);
-#else
- // webgl does not allow separate depth and stencil attachments
- if (samples != 0) {
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_STENCIL, size.width(), size.height());
- } else {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL,
- size.width(), size.height());
- }
- stencil_buffer = depth_buffer;
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
- GL_RENDERBUFFER, depth_buffer);
-#endif
-
- valid = checkFramebufferStatus();
- if (!valid) {
- funcs.glDeleteRenderbuffers(1, &depth_buffer);
- stencil_buffer = depth_buffer = 0;
- }
- }
-
- if (depth_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil
- || (attachment == QGLFramebufferObject::Depth)))
- {
- funcs.glGenRenderbuffers(1, &depth_buffer);
- funcs.glBindRenderbuffer(GL_RENDERBUFFER, depth_buffer);
- Q_ASSERT(funcs.glIsRenderbuffer(depth_buffer));
- if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample)) {
-#ifdef QT_OPENGL_ES
- if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24)) {
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_COMPONENT24_OES, size.width(), size.height());
- } else {
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_COMPONENT16, size.width(), size.height());
- }
-#else
- if (ctx->contextHandle()->isOpenGLES()) {
- if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24))
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_COMPONENT24, size.width(), size.height());
- else
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_COMPONENT16, size.width(), size.height());
- } else {
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
- GL_DEPTH_COMPONENT, size.width(), size.height());
- }
-#endif
- } else {
-#ifdef QT_OPENGL_ES
- if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24)) {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24_OES,
- size.width(), size.height());
- } else {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
- size.width(), size.height());
- }
-#else
- if (ctx->contextHandle()->isOpenGLES()) {
- if (funcs.hasOpenGLExtension(QOpenGLExtensions::Depth24)) {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24,
- size.width(), size.height());
- } else {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
- size.width(), size.height());
- }
- } else {
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, size.width(), size.height());
- }
-#endif
- }
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
- GL_RENDERBUFFER, depth_buffer);
- valid = checkFramebufferStatus();
- if (!valid) {
- funcs.glDeleteRenderbuffers(1, &depth_buffer);
- depth_buffer = 0;
- }
- }
-
- if (stencil_buffer == 0 && (attachment == QGLFramebufferObject::CombinedDepthStencil)) {
- funcs.glGenRenderbuffers(1, &stencil_buffer);
- funcs.glBindRenderbuffer(GL_RENDERBUFFER, stencil_buffer);
- Q_ASSERT(funcs.glIsRenderbuffer(stencil_buffer));
-
-#ifdef QT_OPENGL_ES
- GLenum storage = GL_STENCIL_INDEX8;
-#else
- GLenum storage = ctx->contextHandle()->isOpenGLES() ? GL_STENCIL_INDEX8 : GL_STENCIL_INDEX;
-#endif
-
- if (samples != 0 && funcs.hasOpenGLExtension(QOpenGLExtensions::FramebufferMultisample))
- funcs.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples, storage, size.width(), size.height());
- else
- funcs.glRenderbufferStorage(GL_RENDERBUFFER, storage, size.width(), size.height());
-
- funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
- GL_RENDERBUFFER, stencil_buffer);
- valid = checkFramebufferStatus();
- if (!valid) {
- funcs.glDeleteRenderbuffers(1, &stencil_buffer);
- stencil_buffer = 0;
- }
- }
-
- // The FBO might have become valid after removing the depth or stencil buffer.
- valid = checkFramebufferStatus();
-
- if (depth_buffer && stencil_buffer) {
- fbo_attachment = QGLFramebufferObject::CombinedDepthStencil;
- } else if (depth_buffer) {
- fbo_attachment = QGLFramebufferObject::Depth;
- } else {
- fbo_attachment = QGLFramebufferObject::NoAttachment;
- }
-
- funcs.glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_ptr->current_fbo);
- if (valid) {
- fbo_guard = createSharedResourceGuard(ctx, fbo, freeFramebufferFunc);
- if (color_buffer)
- color_buffer_guard = createSharedResourceGuard(ctx, color_buffer, freeRenderbufferFunc);
- else
- texture_guard = createSharedResourceGuard(ctx, texture, freeTextureFunc);
- if (depth_buffer)
- depth_buffer_guard = createSharedResourceGuard(ctx, depth_buffer, freeRenderbufferFunc);
- if (stencil_buffer) {
- if (stencil_buffer == depth_buffer)
- stencil_buffer_guard = depth_buffer_guard;
- else
- stencil_buffer_guard = createSharedResourceGuard(ctx, stencil_buffer, freeRenderbufferFunc);
- }
- } else {
- if (color_buffer)
- funcs.glDeleteRenderbuffers(1, &color_buffer);
- else
- funcs.glDeleteTextures(1, &texture);
- if (depth_buffer)
- funcs.glDeleteRenderbuffers(1, &depth_buffer);
- if (stencil_buffer && depth_buffer != stencil_buffer)
- funcs.glDeleteRenderbuffers(1, &stencil_buffer);
- funcs.glDeleteFramebuffers(1, &fbo);
- }
- QT_CHECK_GLERROR();
-
- format.setTextureTarget(target);
- format.setSamples(int(samples));
- format.setAttachment(fbo_attachment);
- format.setInternalTextureFormat(internal_format);
- format.setMipmap(mipmap);
-
- glDevice.setFBO(q, attachment);
-}
-
-/*!
- \class QGLFramebufferObject
- \inmodule QtOpenGL
- \brief The QGLFramebufferObject class encapsulates an OpenGL framebuffer object.
- \since 4.2
-
- \obsolete
-
- \ingroup painting-3D
-
- The QGLFramebufferObject class encapsulates an OpenGL framebuffer
- object, defined by the \c{GL_EXT_framebuffer_object} extension. In
- addition it provides a rendering surface that can be painted on
- with a QPainter, rendered to using native GL calls, or both. This
- surface can be bound and used as a regular texture in your own GL
- drawing code. By default, the QGLFramebufferObject class
- generates a 2D GL texture (using the \c{GL_TEXTURE_2D} target),
- which is used as the internal rendering target.
-
- \b{It is important to have a current GL context when creating a
- QGLFramebufferObject, otherwise initialization will fail.}
-
- OpenGL framebuffer objects and pbuffers (see
- \l{QGLPixelBuffer}{QGLPixelBuffer}) can both be used to render to
- offscreen surfaces, but there are a number of advantages with
- using framebuffer objects instead of pbuffers:
-
- \list 1
- \li A framebuffer object does not require a separate rendering
- context, so no context switching will occur when switching
- rendering targets. There is an overhead involved in switching
- targets, but in general it is cheaper than a context switch to a
- pbuffer.
-
- \li Rendering to dynamic textures (i.e. render-to-texture
- functionality) works on all platforms. No need to do explicit copy
- calls from a render buffer into a texture, as was necessary on
- systems that did not support the \c{render_texture} extension.
-
- \li It is possible to attach several rendering buffers (or texture
- objects) to the same framebuffer object, and render to all of them
- without doing a context switch.
-
- \li The OpenGL framebuffer extension is a pure GL extension with no
- system dependant WGL, CGL, or GLX parts. This makes using
- framebuffer objects more portable.
- \endlist
-
- When using a QPainter to paint to a QGLFramebufferObject you should take
- care that the QGLFramebufferObject is created with the CombinedDepthStencil
- attachment for QPainter to be able to render correctly.
- Note that you need to create a QGLFramebufferObject with more than one
- sample per pixel for primitives to be antialiased when drawing using a
- QPainter. To create a multisample framebuffer object you should use one of
- the constructors that take a QGLFramebufferObjectFormat parameter, and set
- the QGLFramebufferObjectFormat::samples() property to a non-zero value.
-
- When painting to a QGLFramebufferObject using QPainter, the state of
- the current GL context will be altered by the paint engine to reflect
- its needs. Applications should not rely upon the GL state being reset
- to its original conditions, particularly the current shader program,
- GL viewport, texture units, and drawing modes.
-
- For multisample framebuffer objects a color render buffer is created,
- otherwise a texture with the specified texture target is created.
- The color render buffer or texture will have the specified internal
- format, and will be bound to the \c GL_COLOR_ATTACHMENT0
- attachment in the framebuffer object.
-
- If you want to use a framebuffer object with multisampling enabled
- as a texture, you first need to copy from it to a regular framebuffer
- object using QGLContext::blitFramebuffer().
-
- \section1 Threading
-
- As of Qt 4.8, it's possible to draw into a QGLFramebufferObject
- using a QPainter in a separate thread. Note that OpenGL 2.0 or
- OpenGL ES 2.0 is required for this to work.
-
- \note This class has been deprecated in favor of QOpenGLFramebufferObject.
-*/
-
-
-/*!
- \enum QGLFramebufferObject::Attachment
- \since 4.3
-
- This enum type is used to configure the depth and stencil buffers
- attached to the framebuffer object when it is created.
-
- \value NoAttachment No attachment is added to the framebuffer object. Note that the
- OpenGL depth and stencil tests won't work when rendering to a
- framebuffer object without any depth or stencil buffers.
- This is the default value.
-
- \value CombinedDepthStencil If the \c GL_EXT_packed_depth_stencil extension is present,
- a combined depth and stencil buffer is attached.
- If the extension is not present, only a depth buffer is attached.
-
- \value Depth A depth buffer is attached to the framebuffer object.
-
- \sa attachment()
-*/
-
-
-/*! \fn QGLFramebufferObject::QGLFramebufferObject(const QSize &size, GLenum target)
-
- Constructs an OpenGL framebuffer object and binds a 2D GL texture
- to the buffer of the size \a size. The texture is bound to the
- \c GL_COLOR_ATTACHMENT0 target in the framebuffer object.
-
- The \a target parameter is used to specify the GL texture
- target. The default target is \c GL_TEXTURE_2D. Keep in mind that
- \c GL_TEXTURE_2D textures must have a power of 2 width and height
- (e.g. 256x512), unless you are using OpenGL 2.0 or higher.
-
- By default, no depth and stencil buffers are attached. This behavior
- can be toggled using one of the overloaded constructors.
-
- The default internal texture format is \c GL_RGBA8 for desktop
- OpenGL, and \c GL_RGBA for OpenGL/ES.
-
- It is important that you have a current GL context set when
- creating the QGLFramebufferObject, otherwise the initialization
- will fail.
-
- \sa size(), texture(), attachment()
-*/
-
-QGLFramebufferObject::QGLFramebufferObject(const QSize &size, GLenum target)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- d->init(this, size, NoAttachment, target,
-#ifndef QT_OPENGL_ES_2
- QOpenGLContext::currentContext()->isOpenGLES() ? GL_RGBA : GL_RGBA8
-#else
- GL_RGBA
-#endif
- );
-}
-
-/*! \overload
-
- Constructs an OpenGL framebuffer object and binds a 2D GL texture
- to the buffer of the given \a width and \a height.
-
- \sa size(), texture()
-*/
-QGLFramebufferObject::QGLFramebufferObject(int width, int height, GLenum target)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- d->init(this, QSize(width, height), NoAttachment, target,
-#ifndef QT_OPENGL_ES_2
- QOpenGLContext::currentContext()->isOpenGLES() ? GL_RGBA : GL_RGBA8
-#else
- GL_RGBA
-#endif
- );
-}
-
-/*! \overload
-
- Constructs an OpenGL framebuffer object of the given \a size based on the
- supplied \a format.
-*/
-
-QGLFramebufferObject::QGLFramebufferObject(const QSize &size, const QGLFramebufferObjectFormat &format)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- d->init(this, size, format.attachment(), format.textureTarget(), format.internalTextureFormat(),
- format.samples(), format.mipmap());
-}
-
-/*! \overload
-
- Constructs an OpenGL framebuffer object of the given \a width and \a height
- based on the supplied \a format.
-*/
-
-QGLFramebufferObject::QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat &format)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- d->init(this, QSize(width, height), format.attachment(), format.textureTarget(),
- format.internalTextureFormat(), format.samples(), format.mipmap());
-}
-
-/*! \overload
-
- Constructs an OpenGL framebuffer object and binds a texture to the
- buffer of the given \a width and \a height.
-
- The \a attachment parameter describes the depth/stencil buffer
- configuration, \a target the texture target and \a internal_format
- the internal texture format. The default texture target is \c
- GL_TEXTURE_2D, while the default internal format is \c GL_RGBA8
- for desktop OpenGL and \c GL_RGBA for OpenGL/ES.
-
- \sa size(), texture(), attachment()
-*/
-QGLFramebufferObject::QGLFramebufferObject(int width, int height, Attachment attachment,
- GLenum target, GLenum internal_format)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- if (!internal_format)
-#ifdef QT_OPENGL_ES_2
- internal_format = GL_RGBA;
-#else
- internal_format = QOpenGLContext::currentContext()->isOpenGLES() ? GL_RGBA : GL_RGBA8;
-#endif
- d->init(this, QSize(width, height), attachment, target, internal_format);
-}
-
-/*! \overload
-
- Constructs an OpenGL framebuffer object and binds a texture to the
- buffer of the given \a size.
-
- The \a attachment parameter describes the depth/stencil buffer
- configuration, \a target the texture target and \a internal_format
- the internal texture format. The default texture target is \c
- GL_TEXTURE_2D, while the default internal format is \c GL_RGBA8
- for desktop OpenGL and \c GL_RGBA for OpenGL/ES.
-
- \sa size(), texture(), attachment()
-*/
-QGLFramebufferObject::QGLFramebufferObject(const QSize &size, Attachment attachment,
- GLenum target, GLenum internal_format)
- : d_ptr(new QGLFramebufferObjectPrivate)
-{
- Q_D(QGLFramebufferObject);
- if (!internal_format)
-#ifdef QT_OPENGL_ES_2
- internal_format = GL_RGBA;
-#else
- internal_format = QOpenGLContext::currentContext()->isOpenGLES() ? GL_RGBA : GL_RGBA8;
-#endif
- d->init(this, size, attachment, target, internal_format);
-}
-
-/*!
- \fn QGLFramebufferObject::~QGLFramebufferObject()
-
- Destroys the framebuffer object and frees any allocated resources.
-*/
-QGLFramebufferObject::~QGLFramebufferObject()
-{
- Q_D(QGLFramebufferObject);
-
- delete d->engine;
-
- if (d->texture_guard)
- d->texture_guard->free();
- if (d->color_buffer_guard)
- d->color_buffer_guard->free();
- if (d->depth_buffer_guard)
- d->depth_buffer_guard->free();
- if (d->stencil_buffer_guard && d->stencil_buffer_guard != d->depth_buffer_guard)
- d->stencil_buffer_guard->free();
- if (d->fbo_guard)
- d->fbo_guard->free();
-}
-
-/*!
- \fn bool QGLFramebufferObject::isValid() const
-
- Returns \c true if the framebuffer object is valid.
-
- The framebuffer can become invalid if the initialization process
- fails, the user attaches an invalid buffer to the framebuffer
- object, or a non-power of two width/height is specified as the
- texture size if the texture target is \c{GL_TEXTURE_2D}.
- The non-power of two limitation does not apply if the OpenGL version
- is 2.0 or higher, or if the GL_ARB_texture_non_power_of_two extension
- is present.
-
- The framebuffer can also become invalid if the QGLContext that
- the framebuffer was created within is destroyed and there are
- no other shared contexts that can take over ownership of the
- framebuffer.
-*/
-bool QGLFramebufferObject::isValid() const
-{
- Q_D(const QGLFramebufferObject);
- return d->valid && d->fbo_guard && d->fbo_guard->id();
-}
-
-/*!
- \fn bool QGLFramebufferObject::bind()
-
- Switches rendering from the default, windowing system provided
- framebuffer to this framebuffer object.
- Returns \c true upon success, false otherwise.
-
- \sa release()
-*/
-bool QGLFramebufferObject::bind()
-{
- if (!isValid())
- return false;
- Q_D(QGLFramebufferObject);
- QGL_FUNC_CONTEXT;
- if (!ctx)
- return false; // Context no longer exists.
- const QGLContext *current = QGLContext::currentContext();
-#ifdef QT_DEBUG
- if (!current ||
- QGLContextPrivate::contextGroup(current) != QGLContextPrivate::contextGroup(ctx))
- {
- qWarning("QGLFramebufferObject::bind() called from incompatible context");
- }
-#endif
- d->funcs.glBindFramebuffer(GL_FRAMEBUFFER, d->fbo());
- d->valid = d->checkFramebufferStatus();
- if (d->valid && current)
- current->d_ptr->setCurrentFbo(d->fbo());
- return d->valid;
-}
-
-/*!
- \fn bool QGLFramebufferObject::release()
-
- Switches rendering back to the default, windowing system provided
- framebuffer.
- Returns \c true upon success, false otherwise.
-
- \sa bind()
-*/
-bool QGLFramebufferObject::release()
-{
- if (!isValid())
- return false;
- Q_D(QGLFramebufferObject);
- QGL_FUNC_CONTEXT;
- if (!ctx)
- return false; // Context no longer exists.
-
- const QGLContext *current = QGLContext::currentContext();
-
-#ifdef QT_DEBUG
- if (!current ||
- QGLContextPrivate::contextGroup(current) != QGLContextPrivate::contextGroup(ctx))
- {
- qWarning("QGLFramebufferObject::release() called from incompatible context");
- }
-#endif
-
- if (current) {
- current->d_ptr->setCurrentFbo(current->d_ptr->default_fbo);
- d->funcs.glBindFramebuffer(GL_FRAMEBUFFER, current->d_ptr->default_fbo);
- }
-
- return true;
-}
-
-/*!
- \fn GLuint QGLFramebufferObject::texture() const
-
- Returns the texture id for the texture attached as the default
- rendering target in this framebuffer object. This texture id can
- be bound as a normal texture in your own GL code.
-
- If a multisample framebuffer object is used then the value returned
- from this function will be invalid.
-*/
-GLuint QGLFramebufferObject::texture() const
-{
- Q_D(const QGLFramebufferObject);
- return d->texture_guard ? d->texture_guard->id() : 0;
-}
-
-/*!
- \fn QSize QGLFramebufferObject::size() const
-
- Returns the size of the texture attached to this framebuffer
- object.
-*/
-QSize QGLFramebufferObject::size() const
-{
- Q_D(const QGLFramebufferObject);
- return d->size;
-}
-
-/*!
- Returns the format of this framebuffer object.
-*/
-QGLFramebufferObjectFormat QGLFramebufferObject::format() const
-{
- Q_D(const QGLFramebufferObject);
- return d->format;
-}
-
-/*!
- \fn QImage QGLFramebufferObject::toImage() const
-
- Returns the contents of this framebuffer object as a QImage.
-
- The returned image has a format of premultiplied ARGB32 or RGB32. The latter is used
- only when internalTextureFormat() is set to \c GL_RGB.
-
- If the rendering in the framebuffer was not done with premultiplied alpha in mind,
- create a wrapper QImage with a non-premultiplied format. This is necessary before
- performing operations like QImage::save() because otherwise the image data would get
- unpremultiplied, even though it was not premultiplied in the first place. To create
- such a wrapper without performing a copy of the pixel data, do the following:
-
- \code
- QImage fboImage(fbo.toImage());
- QImage image(fboImage.constBits(), fboImage.width(), fboImage.height(), QImage::Format_ARGB32);
- \endcode
-
- On QNX the back buffer is not preserved when a buffer swap occures. So this function
- might return old content.
-*/
-QImage QGLFramebufferObject::toImage() const
-{
- Q_D(const QGLFramebufferObject);
- if (!d->valid)
- return QImage();
-
- // qt_gl_read_frame_buffer doesn't work on a multisample FBO
- if (format().samples() != 0) {
- QGLFramebufferObject temp(size(), QGLFramebufferObjectFormat());
-
- QRect rect(QPoint(0, 0), size());
- blitFramebuffer(&temp, rect, const_cast<QGLFramebufferObject *>(this), rect);
-
- return temp.toImage();
- }
-
- bool wasBound = isBound();
- if (!wasBound)
- const_cast<QGLFramebufferObject *>(this)->bind();
- QImage image = qt_gl_read_frame_buffer(d->size, format().internalTextureFormat() != GL_RGB, true);
- if (!wasBound)
- const_cast<QGLFramebufferObject *>(this)->release();
-
- return image;
-}
-
-Q_GLOBAL_STATIC(QGLEngineThreadStorage<QGL2PaintEngineEx>, qt_buffer_2_engine)
-
-/*! \reimp */
-QPaintEngine *QGLFramebufferObject::paintEngine() const
-{
- Q_D(const QGLFramebufferObject);
- if (d->engine)
- return d->engine;
-
- QPaintEngine *engine = qt_buffer_2_engine()->engine();
- if (engine->isActive() && engine->paintDevice() != this) {
- d->engine = new QGL2PaintEngineEx;
- return d->engine;
- }
- return engine;
-}
-
-/*!
- \fn bool QGLFramebufferObject::bindDefault()
-
- Switches rendering back to the default, windowing system provided
- framebuffer.
- Returns \c true upon success, false otherwise.
-
- \sa bind(), release()
-*/
-bool QGLFramebufferObject::bindDefault()
-{
- QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());
-
- if (ctx) {
- QOpenGLFunctions functions(ctx->contextHandle());
- if (!functions.hasOpenGLFeature(QOpenGLFunctions::Framebuffers))
- return false;
-
- ctx->d_ptr->setCurrentFbo(ctx->d_ptr->default_fbo);
- functions.glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_ptr->default_fbo);
-#ifdef QT_DEBUG
- } else {
- qWarning("QGLFramebufferObject::bindDefault() called without current context.");
-#endif
- }
-
- return ctx != 0;
-}
-
-/*!
- \fn bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
-
- Returns \c true if the OpenGL \c{GL_EXT_framebuffer_object} extension
- is present on this system; otherwise returns \c false.
-*/
-bool QGLFramebufferObject::hasOpenGLFramebufferObjects()
-{
- return qgl_hasFeature(QOpenGLFunctions::Framebuffers);
-}
-
-/*!
- \since 4.4
-
- Draws the given texture, \a textureId, to the given target rectangle,
- \a target, in OpenGL model space. The \a textureTarget should be a 2D
- texture target.
-
- The framebuffer object should be bound when calling this function.
-
- Equivalent to the corresponding QGLContext::drawTexture().
-*/
-void QGLFramebufferObject::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
-{
- const_cast<QGLContext *>(QGLContext::currentContext())->drawTexture(target, textureId, textureTarget);
-}
-
-/*!
- \since 4.4
-
- Draws the given texture, \a textureId, at the given \a point in OpenGL
- model space. The \a textureTarget should be a 2D texture target.
-
- The framebuffer object should be bound when calling this function.
-
- Equivalent to the corresponding QGLContext::drawTexture().
-*/
-void QGLFramebufferObject::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
-{
- const_cast<QGLContext *>(QGLContext::currentContext())->drawTexture(point, textureId, textureTarget);
-}
-
-/*! \reimp */
-int QGLFramebufferObject::metric(PaintDeviceMetric metric) const
-{
- Q_D(const QGLFramebufferObject);
-
- float dpmx = qt_defaultDpiX()*100./2.54;
- float dpmy = qt_defaultDpiY()*100./2.54;
- int w = d->size.width();
- int h = d->size.height();
- switch (metric) {
- case PdmWidth:
- return w;
-
- case PdmHeight:
- return h;
-
- case PdmWidthMM:
- return qRound(w * 1000 / dpmx);
-
- case PdmHeightMM:
- return qRound(h * 1000 / dpmy);
-
- case PdmNumColors:
- return 0;
-
- case PdmDepth:
- return 32;//d->depth;
-
- case PdmDpiX:
- return qRound(dpmx * 0.0254);
-
- case PdmDpiY:
- return qRound(dpmy * 0.0254);
-
- case PdmPhysicalDpiX:
- return qRound(dpmx * 0.0254);
-
- case PdmPhysicalDpiY:
- return qRound(dpmy * 0.0254);
-
- case QPaintDevice::PdmDevicePixelRatio:
- return 1;
-
- case QPaintDevice::PdmDevicePixelRatioScaled:
- return 1 * QPaintDevice::devicePixelRatioFScale();
-
- default:
- qWarning("QGLFramebufferObject::metric(), Unhandled metric type: %d.\n", metric);
- break;
- }
- return 0;
-}
-
-/*!
- \fn GLuint QGLFramebufferObject::handle() const
-
- Returns the GL framebuffer object handle for this framebuffer
- object (returned by the \c{glGenFrameBuffersEXT()} function). This
- handle can be used to attach new images or buffers to the
- framebuffer. The user is responsible for cleaning up and
- destroying these objects.
-*/
-GLuint QGLFramebufferObject::handle() const
-{
- Q_D(const QGLFramebufferObject);
- return d->fbo();
-}
-
-/*! \fn int QGLFramebufferObject::devType() const
- \internal
-*/
-
-
-/*!
- Returns the status of the depth and stencil buffers attached to
- this framebuffer object.
-*/
-
-QGLFramebufferObject::Attachment QGLFramebufferObject::attachment() const
-{
- Q_D(const QGLFramebufferObject);
- if (d->valid)
- return d->fbo_attachment;
- return NoAttachment;
-}
-
-/*!
- \since 4.5
-
- Returns \c true if the framebuffer object is currently bound to a context,
- otherwise false is returned.
-*/
-
-bool QGLFramebufferObject::isBound() const
-{
- Q_D(const QGLFramebufferObject);
- const QGLContext *current = QGLContext::currentContext();
- if (current) {
- current->d_ptr->refreshCurrentFbo();
- return current->d_ptr->current_fbo == d->fbo();
- }
-
- return false;
-}
-
-/*!
- \fn bool QGLFramebufferObject::hasOpenGLFramebufferBlit()
-
- \since 4.6
-
- Returns \c true if the OpenGL \c{GL_EXT_framebuffer_blit} extension
- is present on this system; otherwise returns \c false.
-
- \sa blitFramebuffer()
-*/
-bool QGLFramebufferObject::hasOpenGLFramebufferBlit()
-{
- return QOpenGLExtensions(QOpenGLContext::currentContext()).hasOpenGLExtension(QOpenGLExtensions::FramebufferBlit);
-}
-
-/*!
- \since 4.6
-
- Blits from the \a sourceRect rectangle in the \a source framebuffer
- object to the \a targetRect rectangle in the \a target framebuffer object.
-
- If \a source or \a target is 0, the default framebuffer will be used
- instead of a framebuffer object as source or target respectively.
-
- The \a buffers parameter should be a mask consisting of any combination of
- \c GL_COLOR_BUFFER_BIT, \c GL_DEPTH_BUFFER_BIT, and
- \c GL_STENCIL_BUFFER_BIT. Any buffer type that is not present both
- in the source and target buffers is ignored.
-
- The \a sourceRect and \a targetRect rectangles may have different sizes;
- in this case \a buffers should not contain \c GL_DEPTH_BUFFER_BIT or
- \c GL_STENCIL_BUFFER_BIT. The \a filter parameter should be set to
- \c GL_LINEAR or \c GL_NEAREST, and specifies whether linear or nearest
- interpolation should be used when scaling is performed.
-
- If \a source equals \a target a copy is performed within the same buffer.
- Results are undefined if the source and target rectangles overlap and
- have different sizes. The sizes must also be the same if any of the
- framebuffer objects are multisample framebuffers.
-
- Note that the scissor test will restrict the blit area if enabled.
-
- This function will have no effect unless hasOpenGLFramebufferBlit() returns
- true.
-
- \sa hasOpenGLFramebufferBlit()
-*/
-void QGLFramebufferObject::blitFramebuffer(QGLFramebufferObject *target, const QRect &targetRect,
- QGLFramebufferObject *source, const QRect &sourceRect,
- GLbitfield buffers,
- GLenum filter)
-{
- const QGLContext *ctx = QGLContext::currentContext();
- if (!ctx || !ctx->contextHandle())
- return;
-
- QOpenGLExtensions functions(ctx->contextHandle());
- if (!functions.hasOpenGLExtension(QOpenGLExtensions::FramebufferBlit))
- return;
-
- QSurface *surface = ctx->contextHandle()->surface();
-
- const int height = static_cast<QWindow *>(surface)->height();
-
- const int sh = source ? source->height() : height;
- const int th = target ? target->height() : height;
-
- const int sx0 = sourceRect.left();
- const int sx1 = sourceRect.left() + sourceRect.width();
- const int sy0 = sh - (sourceRect.top() + sourceRect.height());
- const int sy1 = sh - sourceRect.top();
-
- const int tx0 = targetRect.left();
- const int tx1 = targetRect.left() + targetRect.width();
- const int ty0 = th - (targetRect.top() + targetRect.height());
- const int ty1 = th - targetRect.top();
-
- ctx->d_ptr->refreshCurrentFbo();
-
- functions.glBindFramebuffer(GL_READ_FRAMEBUFFER, source ? source->handle() : 0);
- functions.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target ? target->handle() : 0);
-
- functions.glBlitFramebuffer(sx0, sy0, sx1, sy1,
- tx0, ty0, tx1, ty1,
- buffers, filter);
-
- functions.glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_ptr->current_fbo);
-}
-
-QT_END_NAMESPACE
diff --git a/src/opengl/qglframebufferobject.h b/src/opengl/qglframebufferobject.h
deleted file mode 100644
index c88063cbb5..0000000000
--- a/src/opengl/qglframebufferobject.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGLFRAMEBUFFEROBJECT_H
-#define QGLFRAMEBUFFEROBJECT_H
-
-#include <QtOpenGL/qgl.h>
-#include <QtGui/qpaintdevice.h>
-
-QT_BEGIN_NAMESPACE
-
-
-class QGLFramebufferObjectPrivate;
-class QGLFramebufferObjectFormat;
-
-class Q_OPENGL_EXPORT QGLFramebufferObject : public QPaintDevice
-{
- Q_DECLARE_PRIVATE(QGLFramebufferObject)
-public:
- enum Attachment {
- NoAttachment,
- CombinedDepthStencil,
- Depth
- };
-
- QGLFramebufferObject(const QSize &size, GLenum target = GL_TEXTURE_2D);
- QGLFramebufferObject(int width, int height, GLenum target = GL_TEXTURE_2D);
-
- QGLFramebufferObject(const QSize &size, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = 0);
- QGLFramebufferObject(int width, int height, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = 0);
-
- QGLFramebufferObject(const QSize &size, const QGLFramebufferObjectFormat &format);
- QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat &format);
-
- virtual ~QGLFramebufferObject();
-
- QGLFramebufferObjectFormat format() const;
-
- bool isValid() const;
- bool isBound() const;
- bool bind();
- bool release();
-
- GLuint texture() const;
- QSize size() const;
- QImage toImage() const;
- Attachment attachment() const;
-
- QPaintEngine *paintEngine() const override;
- GLuint handle() const;
-
- static bool bindDefault();
-
- static bool hasOpenGLFramebufferObjects();
-
- void drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
- void drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget = GL_TEXTURE_2D);
-
- static bool hasOpenGLFramebufferBlit();
- static void blitFramebuffer(QGLFramebufferObject *target, const QRect &targetRect,
- QGLFramebufferObject *source, const QRect &sourceRect,
- GLbitfield buffers = GL_COLOR_BUFFER_BIT,
- GLenum filter = GL_NEAREST);
-
-protected:
- int metric(PaintDeviceMetric metric) const override;
- int devType() const override { return QInternal::FramebufferObject; }
-
-private:
- Q_DISABLE_COPY(QGLFramebufferObject)
- QScopedPointer<QGLFramebufferObjectPrivate> d_ptr;
- friend class QGLPaintDevice;
- friend class QGLFBOGLPaintDevice;
-};
-
-class QGLFramebufferObjectFormatPrivate;
-class Q_OPENGL_EXPORT QGLFramebufferObjectFormat
-{
-public:
- QGLFramebufferObjectFormat();
- QGLFramebufferObjectFormat(const QGLFramebufferObjectFormat &other);
- QGLFramebufferObjectFormat &operator=(const QGLFramebufferObjectFormat &other);
- ~QGLFramebufferObjectFormat();
-
- void setSamples(int samples);
- int samples() const;
-
- void setMipmap(bool enabled);
- bool mipmap() const;
-
- void setAttachment(QGLFramebufferObject::Attachment attachment);
- QGLFramebufferObject::Attachment attachment() const;
-
- void setTextureTarget(GLenum target);
- GLenum textureTarget() const;
-
- void setInternalTextureFormat(GLenum internalTextureFormat);
- GLenum internalTextureFormat() const;
-
- bool operator==(const QGLFramebufferObjectFormat& other) const;
- bool operator!=(const QGLFramebufferObjectFormat& other) const;
-
-private:
- QGLFramebufferObjectFormatPrivate *d;
-
- void detach();
-};
-
-QT_END_NAMESPACE
-
-#endif // QGLFRAMEBUFFEROBJECT_H
diff --git a/src/opengl/qglframebufferobject_p.h b/src/opengl/qglframebufferobject_p.h
deleted file mode 100644
index 9d536527c3..0000000000
--- a/src/opengl/qglframebufferobject_p.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QGLFRAMEBUFFEROBJECT_P_H
-#define QGLFRAMEBUFFEROBJECT_P_H
-
-//
-// W A R N I N G
-// -------------
-//
-// This file is not part of the Qt API. It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <qglframebufferobject.h>
-#include <private/qglpaintdevice_p.h>
-#include <private/qgl_p.h>
-#include <private/qopenglextensions_p.h>
-
-QT_BEGIN_NAMESPACE
-
-class QGLFramebufferObjectFormatPrivate
-{
-public:
- QGLFramebufferObjectFormatPrivate()
- : ref(1),
- samples(0),
- attachment(QGLFramebufferObject::NoAttachment),
- target(GL_TEXTURE_2D),
- mipmap(false)
- {
-#ifndef QT_OPENGL_ES_2
- QOpenGLContext *ctx = QOpenGLContext::currentContext();
- const bool isES = ctx ? ctx->isOpenGLES() : QOpenGLContext::openGLModuleType() != QOpenGLContext::LibGL;
- internal_format = isES ? GL_RGBA : GL_RGBA8;
-#else
- internal_format = GL_RGBA;
-#endif
- }
- QGLFramebufferObjectFormatPrivate
- (const QGLFramebufferObjectFormatPrivate *other)
- : ref(1),
- samples(other->samples),
- attachment(other->attachment),
- target(other->target),
- internal_format(other->internal_format),
- mipmap(other->mipmap)
- {
- }
- bool equals(const QGLFramebufferObjectFormatPrivate *other)
- {
- return samples == other->samples &&
- attachment == other->attachment &&
- target == other->target &&
- internal_format == other->internal_format &&
- mipmap == other->mipmap;
- }
-
- QAtomicInt ref;
- int samples;
- QGLFramebufferObject::Attachment attachment;
- GLenum target;
- GLenum internal_format;
- uint mipmap : 1;
-};
-
-class QGLFBOGLPaintDevice : public QGLPaintDevice
-{
-public:
- virtual QPaintEngine* paintEngine() const override {return fbo->paintEngine();}
- virtual QSize size() const override {return fbo->size();}
- virtual QGLContext* context() const override;
- virtual QGLFormat format() const override {return fboFormat;}
- virtual bool alphaRequested() const override { return reqAlpha; }
-
- void setFBO(QGLFramebufferObject* f,
- QGLFramebufferObject::Attachment attachment);
-
-private:
- QGLFramebufferObject* fbo;
- QGLFormat fboFormat;
- bool reqAlpha;
-};
-
-class QGLFramebufferObjectPrivate
-{
-public:
- QGLFramebufferObjectPrivate() : fbo_guard(nullptr), texture_guard(nullptr), depth_buffer_guard(nullptr)
- , stencil_buffer_guard(nullptr), color_buffer_guard(nullptr)
- , valid(false), engine(nullptr) {}
- ~QGLFramebufferObjectPrivate() {}
-
- void init(QGLFramebufferObject *q, const QSize& sz,
- QGLFramebufferObject::Attachment attachment,
- GLenum internal_format, GLenum texture_target,
- GLint samples = 0, bool mipmap = false);
- bool checkFramebufferStatus() const;
- QGLSharedResourceGuardBase *fbo_guard;
- QGLSharedResourceGuardBase *texture_guard;
- QGLSharedResourceGuardBase *depth_buffer_guard;
- QGLSharedResourceGuardBase *stencil_buffer_guard;
- QGLSharedResourceGuardBase *color_buffer_guard;
- GLenum target;
- QSize size;
- QGLFramebufferObjectFormat format;
- uint valid : 1;
- QGLFramebufferObject::Attachment fbo_attachment;
- mutable QPaintEngine *engine;
- QGLFBOGLPaintDevice glDevice;
- QOpenGLExtensions funcs;
-
- inline GLuint fbo() const { return fbo_guard ? fbo_guard->id() : 0; }
-};
-
-
-QT_END_NAMESPACE
-
-#endif // QGLFRAMEBUFFEROBJECT_P_H
diff --git a/src/opengl/qglfunctions.cpp b/src/opengl/qglfunctions.cpp
deleted file mode 100644
index b20311bec4..0000000000
--- a/src/opengl/qglfunctions.cpp
+++ /dev/null
@@ -1,1330 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtOpenGL module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qglfunctions.h"
-#include "qgl_p.h"
-#include "QtGui/private/qopenglcontext_p.h"
-#include <private/qopengl_p.h>
-
-QT_BEGIN_NAMESPACE
-
-/*!
- \class QGLFunctions
- \inmodule QtOpenGL
- \brief The QGLFunctions class provides cross-platform access to the OpenGL ES 2.0 API.
- \since 4.8
- \obsolete
- \ingroup painting-3D
-
- OpenGL ES 2.0 defines a subset of the OpenGL specification that is
- common across many desktop and embedded OpenGL implementations.
- However, it can be difficult to use the functions from that subset
- because they need to be resolved manually on desktop systems.
-
- QGLFunctions provides a guaranteed API that is available on all
- OpenGL systems and takes care of function resolution on systems
- that need it. The recommended way to use QGLFunctions is by
- direct inheritance:
-
- \snippet code/src_opengl_qglfunctions.cpp 0
-
- The \c{paintGL()} function can then use any of the OpenGL ES 2.0
- functions without explicit resolution, such as glActiveTexture()
- in the following example:
-
- \snippet code/src_opengl_qglfunctions.cpp 1
-
- QGLFunctions can also be used directly for ad-hoc invocation
- of OpenGL ES 2.0 functions on all platforms:
-
- \snippet code/src_opengl_qglfunctions.cpp 2
-
- QGLFunctions provides wrappers for all OpenGL ES 2.0 functions,
- except those like \c{glDrawArrays()}, \c{glViewport()}, and
- \c{glBindTexture()} that don't have portability issues.
-
- Including the header for QGLFunctions will also define all of
- the OpenGL ES 2.0 macro constants that are not already defined by
- the system's OpenGL headers, such as \c{GL_TEXTURE1} above.
-
- The hasOpenGLFeature() and openGLFeatures() functions can be used
- to determine if the OpenGL implementation has a major OpenGL ES 2.0
- feature. For example, the following checks if non power of two
- textures are available:
-
- \snippet code/src_opengl_qglfunctions.cpp 3
-
- \note This class has been deprecated in favor of QOpenGLFunctions.
-*/
-
-/*!
- \enum QGLFunctions::OpenGLFeature
- This enum defines OpenGL ES 2.0 features that may be optional
- on other platforms.
-
- \value Multitexture glActiveTexture() function is available.
- \value Shaders Shader functions are available.
- \value Buffers Vertex and index buffer functions are available.
- \value Framebuffers Framebuffer object functions are available.
- \value BlendColor glBlendColor() is available.
- \value BlendEquation glBlendEquation() is available.
- \value BlendEquationSeparate glBlendEquationSeparate() is available.
- \value BlendFuncSeparate glBlendFuncSeparate() is available.
- \value BlendSubtract Blend subtract mode is available.
- \value CompressedTextures Compressed texture functions are available.
- \value Multisample glSampleCoverage() function is available.
- \value StencilSeparate Separate stencil functions are available.
- \value NPOTTextures Non power of two textures are available.
-*/
-
-// Hidden private fields for additional extension data.
-struct QGLFunctionsPrivateEx : public QGLFunctionsPrivate, public QOpenGLSharedResource
-{
- QGLFunctionsPrivateEx(QOpenGLContext *context)
- : QGLFunctionsPrivate(QGLContext::fromOpenGLContext(context))
- , QOpenGLSharedResource(context->shareGroup())
- , m_features(-1)
- {
- funcs = new QOpenGLFunctions(context);
- funcs->initializeOpenGLFunctions();
- }
-
- ~QGLFunctionsPrivateEx()
- {
- delete funcs;
- }
-
- void invalidateResource() override
- {
- m_features = -1;
- }
-
- void freeResource(QOpenGLContext *) override
- {
- // no gl resources to free
- }
-
- int m_features;
-};
-
-Q_GLOBAL_STATIC(QOpenGLMultiGroupSharedResource, qt_gl_functions_resource)
-
-static QGLFunctionsPrivateEx *qt_gl_functions(const QGLContext *context = 0)
-{
- if (!context)
- context = QGLContext::currentContext();
- Q_ASSERT(context);
- QGLFunctionsPrivateEx *funcs =
- reinterpret_cast<QGLFunctionsPrivateEx *>
- (qt_gl_functions_resource()->value<QGLFunctionsPrivateEx>(context->contextHandle()));
- return funcs;
-}
-
-/*!
- Constructs a default function resolver. The resolver cannot
- be used until initializeGLFunctions() is called to specify
- the context.
-
- \sa initializeGLFunctions()
-*/
-QGLFunctions::QGLFunctions()
- : d_ptr(0)
-{
-}
-
-/*!
- Constructs a function resolver for \a context. If \a context
- is \nullptr, then the resolver will be created for the current
- QGLContext.
-
- An object constructed in this way can only be used with \a context
- and other contexts that share with it. Use initializeGLFunctions()
- to change the object's context association.
-
- \sa initializeGLFunctions()
-*/
-QGLFunctions::QGLFunctions(const QGLContext *context)
- : d_ptr(qt_gl_functions(context))
-{
-}
-
-/*!
- \fn QGLFunctions::~QGLFunctions()
-
- Destroys this function resolver.
-*/
-
-static int qt_gl_resolve_features()
-{
- QOpenGLContext *ctx = QOpenGLContext::currentContext();
- if (ctx->isOpenGLES()) {
- // OpenGL ES 2
- int features = QGLFunctions::Multitexture |
- QGLFunctions::Shaders |
- QGLFunctions::Buffers |
- QGLFunctions::Framebuffers |
- QGLFunctions::BlendColor |
- QGLFunctions::BlendEquation |
- QGLFunctions::BlendEquationSeparate |
- QGLFunctions::BlendFuncSeparate |
- QGLFunctions::BlendSubtract |
- QGLFunctions::CompressedTextures |
- QGLFunctions::Multisample |
- QGLFunctions::StencilSeparate;
- QOpenGLExtensionMatcher extensions;
- if (extensions.match("GL_OES_texture_npot"))
- features |= QGLFunctions::NPOTTextures;
- if (extensions.match("GL_IMG_texture_npot"))
- features |= QGLFunctions::NPOTTextures;
- return features;
- } else {
- // OpenGL
- int features = 0;
- QGLFormat::OpenGLVersionFlags versions = QGLFormat::openGLVersionFlags();
- QOpenGLExtensionMatcher extensions;
-
- // Recognize features by extension name.
- if (extensions.match("GL_ARB_multitexture"))
- features |= QGLFunctions::Multitexture;
- if (extensions.match("GL_ARB_shader_objects"))
- features |= QGLFunctions::Shaders;
- if (extensions.match("GL_EXT_framebuffer_object") ||
- extensions.match("GL_ARB_framebuffer_object"))
- features |= QGLFunctions::Framebuffers;
- if (extensions.match("GL_EXT_blend_color"))
- features |= QGLFunctions::BlendColor;
- if (extensions.match("GL_EXT_blend_equation_separate"))
- features |= QGLFunctions::BlendEquationSeparate;
- if (extensions.match("GL_EXT_blend_func_separate"))
- features |= QGLFunctions::BlendFuncSeparate;
- if (extensions.match("GL_EXT_blend_subtract"))
- features |= QGLFunctions::BlendSubtract;
- if (extensions.match("GL_ARB_texture_compression"))
- features |= QGLFunctions::CompressedTextures;
- if (extensions.match("GL_ARB_multisample"))
- features |= QGLFunctions::Multisample;
- if (extensions.match("GL_ARB_texture_non_power_of_two"))
- features |= QGLFunctions::NPOTTextures;
-
- // Recognize features by minimum OpenGL version.
- if (versions & QGLFormat::OpenGL_Version_1_2) {
- features |= QGLFunctions::BlendColor |
- QGLFunctions::BlendEquation;
- }
- if (versions & QGLFormat::OpenGL_Version_1_3) {
- features |= QGLFunctions::Multitexture |
- QGLFunctions::CompressedTextures |
- QGLFunctions::Multisample;
- }
- if (versions & QGLFormat::OpenGL_Version_1_4)
- features |= QGLFunctions::BlendFuncSeparate;
- if (versions & QGLFormat::OpenGL_Version_1_5)
- features |= QGLFunctions::Buffers;
- if (versions & QGLFormat::OpenGL_Version_2_0) {
- features |= QGLFunctions::Shaders |
- QGLFunctions::StencilSeparate |
- QGLFunctions::BlendEquationSeparate |
- QGLFunctions::NPOTTextures;
- }
- return features;
- }
-}
-
-/*!
- Returns the set of features that are present on this system's
- OpenGL implementation.
-
- It is assumed that the QGLContext associated with this function
- resolver is current.
-
- \sa hasOpenGLFeature()
-*/
-QGLFunctions::OpenGLFeatures QGLFunctions::openGLFeatures() const
-{
- QGLFunctionsPrivateEx *d = static_cast<QGLFunctionsPrivateEx *>(d_ptr);
- if (!d)
- return { };
- if (d->m_features == -1)
- d->m_features = qt_gl_resolve_features();
- return QGLFunctions::OpenGLFeatures(d->m_features);
-}
-
-/*!
- Returns \c true if \a feature is present on this system's OpenGL
- implementation; false otherwise.
-
- It is assumed that the QGLContext associated with this function
- resolver is current.
-
- \sa openGLFeatures()
-*/
-bool QGLFunctions::hasOpenGLFeature(QGLFunctions::OpenGLFeature feature) const
-{
- QGLFunctionsPrivateEx *d = static_cast<QGLFunctionsPrivateEx *>(d_ptr);
- if (!d)
- return false;
- if (d->m_features == -1)
- d->m_features = qt_gl_resolve_features();
- return (d->m_features & int(feature)) != 0;
-}
-
-/*!
- Initializes GL function resolution for \a context. If \a context
- is \nullptr, then the current QGLContext will be used.
-
- After calling this function, the QGLFunctions object can only be
- used with \a context and other contexts that share with it.
- Call initializeGLFunctions() again to change the object's context
- association.
-*/
-void QGLFunctions::initializeGLFunctions(const QGLContext *context)
-{
- d_ptr = qt_gl_functions(context);
-}
-
-/*!
- \fn void QGLFunctions::glActiveTexture(GLenum texture)
-
- Convenience function that calls glActiveTexture(\a texture).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glActiveTexture.xml}{glActiveTexture()}.
-*/
-
-/*!
- \fn void QGLFunctions::glAttachShader(GLuint program, GLuint shader)
-
- Convenience function that calls glAttachShader(\a program, \a shader).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glAttachShader.xml}{glAttachShader()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
-
- Convenience function that calls glBindAttribLocation(\a program, \a index, \a name).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBindAttribLocation.xml}{glBindAttribLocation()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
-
- Convenience function that calls glBindBuffer(\a target, \a buffer).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBindBuffer.xml}{glBindBuffer()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffer)
-
- Convenience function that calls glBindFramebuffer(\a target, \a framebuffer).
-
- Note that Qt will translate a \a framebuffer argument of 0 to the currently
- bound QOpenGLContext's defaultFramebufferObject().
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBindFramebuffer.xml}{glBindFramebuffer()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
-
- Convenience function that calls glBindRenderbuffer(\a target, \a renderbuffer).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBindRenderbuffer.xml}{glBindRenderbuffer()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-
- Convenience function that calls glBlendColor(\a red, \a green, \a blue, \a alpha).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBlendColor.xml}{glBlendColor()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBlendEquation(GLenum mode)
-
- Convenience function that calls glBlendEquation(\a mode).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBlendEquation.xml}{glBlendEquation()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-
- Convenience function that calls glBlendEquationSeparate(\a modeRGB, \a modeAlpha).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBlendEquationSeparate.xml}{glBlendEquationSeparate()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-
- Convenience function that calls glBlendFuncSeparate(\a srcRGB, \a dstRGB, \a srcAlpha, \a dstAlpha).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBlendFuncSeparate.xml}{glBlendFuncSeparate()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
-
- Convenience function that calls glBufferData(\a target, \a size, \a data, \a usage).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBufferData.xml}{glBufferData()}.
-*/
-
-/*!
- \fn void QGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
-
- Convenience function that calls glBufferSubData(\a target, \a offset, \a size, \a data).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glBufferSubData.xml}{glBufferSubData()}.
-*/
-
-/*!
- \fn GLenum QGLFunctions::glCheckFramebufferStatus(GLenum target)
-
- Convenience function that calls glCheckFramebufferStatus(\a target).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCheckFramebufferStatus.xml}{glCheckFramebufferStatus()}.
-*/
-
-/*!
- \fn void QGLFunctions::glClearDepthf(GLclampf depth)
-
- Convenience function that calls glClearDepth(\a depth) on
- desktop OpenGL systems and glClearDepthf(\a depth) on
- embedded OpenGL ES systems.
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glClearDepthf.xml}{glClearDepthf()}.
-*/
-
-/*!
- \fn void QGLFunctions::glCompileShader(GLuint shader)
-
- Convenience function that calls glCompileShader(\a shader).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCompileShader.xml}{glCompileShader()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
-
- Convenience function that calls glCompressedTexImage2D(\a target, \a level, \a internalformat, \a width, \a height, \a border, \a imageSize, \a data).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCompressedTexImage2D.xml}{glCompressedTexImage2D()}.
-*/
-
-/*!
- \fn void QGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
-
- Convenience function that calls glCompressedTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a width, \a height, \a format, \a imageSize, \a data).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCompressedTexSubImage2D.xml}{glCompressedTexSubImage2D()}.
-*/
-
-/*!
- \fn GLuint QGLFunctions::glCreateProgram()
-
- Convenience function that calls glCreateProgram().
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCreateProgram.xml}{glCreateProgram()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn GLuint QGLFunctions::glCreateShader(GLenum type)
-
- Convenience function that calls glCreateShader(\a type).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glCreateShader.xml}{glCreateShader()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
-
- Convenience function that calls glDeleteBuffers(\a n, \a buffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteBuffers.xml}{glDeleteBuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
-
- Convenience function that calls glDeleteFramebuffers(\a n, \a framebuffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteFramebuffers.xml}{glDeleteFramebuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glDeleteProgram(GLuint program)
-
- Convenience function that calls glDeleteProgram(\a program).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteProgram.xml}{glDeleteProgram()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
-
- Convenience function that calls glDeleteRenderbuffers(\a n, \a renderbuffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteRenderbuffers.xml}{glDeleteRenderbuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glDeleteShader(GLuint shader)
-
- Convenience function that calls glDeleteShader(\a shader).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteShader.xml}{glDeleteShader()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
-
- Convenience function that calls glDepthRange(\a zNear, \a zFar) on
- desktop OpenGL systems and glDepthRangef(\a zNear, \a zFar) on
- embedded OpenGL ES systems.
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDepthRangef.xml}{glDepthRangef()}.
-*/
-
-/*!
- \fn void QGLFunctions::glDetachShader(GLuint program, GLuint shader)
-
- Convenience function that calls glDetachShader(\a program, \a shader).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDetachShader.xml}{glDetachShader()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glDisableVertexAttribArray(GLuint index)
-
- Convenience function that calls glDisableVertexAttribArray(\a index).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glDisableVertexAttribArray.xml}{glDisableVertexAttribArray()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glEnableVertexAttribArray(GLuint index)
-
- Convenience function that calls glEnableVertexAttribArray(\a index).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glEnableVertexAttribArray.xml}{glEnableVertexAttribArray()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-
- Convenience function that calls glFramebufferRenderbuffer(\a target, \a attachment, \a renderbuffertarget, \a renderbuffer).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glFramebufferRenderbuffer.xml}{glFramebufferRenderbuffer()}.
-*/
-
-/*!
- \fn void QGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-
- Convenience function that calls glFramebufferTexture2D(\a target, \a attachment, \a textarget, \a texture, \a level).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glFramebufferTexture2D.xml}{glFramebufferTexture2D()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
-
- Convenience function that calls glGenBuffers(\a n, \a buffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGenBuffers.xml}{glGenBuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGenerateMipmap(GLenum target)
-
- Convenience function that calls glGenerateMipmap(\a target).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGenerateMipmap.xml}{glGenerateMipmap()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
-
- Convenience function that calls glGenFramebuffers(\a n, \a framebuffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGenFramebuffers.xml}{glGenFramebuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
-
- Convenience function that calls glGenRenderbuffers(\a n, \a renderbuffers).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGenRenderbuffers.xml}{glGenRenderbuffers()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-
- Convenience function that calls glGetActiveAttrib(\a program, \a index, \a bufsize, \a length, \a size, \a type, \a name).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetActiveAttrib.xml}{glGetActiveAttrib()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-
- Convenience function that calls glGetActiveUniform(\a program, \a index, \a bufsize, \a length, \a size, \a type, \a name).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetActiveUniform.xml}{glGetActiveUniform()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
-
- Convenience function that calls glGetAttachedShaders(\a program, \a maxcount, \a count, \a shaders).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetAttachedShaders.xml}{glGetAttachedShaders()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn int QGLFunctions::glGetAttribLocation(GLuint program, const char* name)
-
- Convenience function that calls glGetAttribLocation(\a program, \a name).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetAttribLocation.xml}{glGetAttribLocation()}.
-
- This convenience function will do nothing on OpenGL ES 1.x systems.
-*/
-
-/*!
- \fn void QGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
-
- Convenience function that calls glGetBufferParameteriv(\a target, \a pname, \a params).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetBufferParameteriv.xml}{glGetBufferParameteriv()}.
-*/
-
-/*!
- \fn void QGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
-
- Convenience function that calls glGetFramebufferAttachmentParameteriv(\a target, \a attachment, \a pname, \a params).
-
- For more information, see the OpenGL ES 2.0 documentation for
- \l{http://www.khronos.org/opengles/sdk/docs/man/glGetFramebufferAttachmentParameteriv.xml}{glGetFramebufferAttachmentParameteriv()}.
-*/