OpenGL: Add a set of version and context specific OpenGL classes

This commit adds part of the output of utils/glgen and some simple
modifications to QOpenGLContext to allow easy access to classes
containing functions specific to a given OpenGL context and version.

This allows compile-time detection of mis-use of OpenGL features.
For example, trying to use glBegin(GL_TRIANGLES) with an OpenGL 3.2
Core Profile context will be detected by the compiler rather than at
runtime.

These capabilities make it much easier to add functionality to Qt and
applications that relies upon core features of OpenGL from specific
versions e.g. geometry shaders.

Change-Id: Ieb584a489792595f831bc77dee84935c03bb5a64
Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>

1 files changed, 297 insertions, 0 deletions

diff --git a/src/gui/opengl/qopenglfunctions_2_1.cpp b/src/gui/opengl/qopenglfunctions_2_1.cpp
new file mode 100644
index 0000000000..143ac206ed
--- /dev/null
+++ b/src/gui/opengl/qopenglfunctions_2_1.cpp
@@ -0,0 +1,297 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/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 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+**
+** This file was generated by glgen version 0.1
+** Command line was: glgen
+**
+** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+**
+** This is an auto-generated file.
+** Do not edit! All changes made to it will be lost.
+**
+****************************************************************************/
+
+#include "qopenglfunctions_2_1.h"
+#include "qopenglcontext.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QOpenGLFunctions_2_1
+    \inmodule QtGui
+    \since 5.1
+    \brief The QOpenGLFunctions_2_1 class provides all functions for this version and profile of OpenGL.
+
+    \sa QAbstractOpenGLFunctions
+*/
+
+QOpenGLFunctions_2_1::QOpenGLFunctions_2_1()
+ : QAbstractOpenGLFunctions()
+ , d_1_0_Core(0)
+ , d_1_1_Core(0)
+ , d_1_2_Core(0)
+ , d_1_3_Core(0)
+ , d_1_4_Core(0)
+ , d_1_5_Core(0)
+ , d_2_0_Core(0)
+ , d_2_1_Core(0)
+ , d_1_0_Deprecated(0)
+ , d_1_1_Deprecated(0)
+ , d_1_2_Deprecated(0)
+ , d_1_3_Deprecated(0)
+ , d_1_4_Deprecated(0)
+ , d_2_0_Deprecated(0)
+{
+}
+
+QOpenGLFunctions_2_1::~QOpenGLFunctions_2_1()
+{
+    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
+        delete d_1_0_Core;
+    }
+    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
+        delete d_1_1_Core;
+    }
+    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
+        delete d_1_2_Core;
+    }
+    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
+        delete d_1_3_Core;
+    }
+    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
+        delete d_1_4_Core;
+    }
+    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
+        delete d_1_5_Core;
+    }
+    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
+        delete d_2_0_Core;
+    }
+    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
+        delete d_2_1_Core;
+    }
+    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
+        delete d_1_0_Deprecated;
+    }
+    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
+        delete d_1_1_Deprecated;
+    }
+    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
+        delete d_1_2_Deprecated;
+    }
+    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
+        delete d_1_3_Deprecated;
+    }
+    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
+        delete d_1_4_Deprecated;
+    }
+    if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
+        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
+        delete d_2_0_Deprecated;
+    }
+}
+
+bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
+{
+    if ( isInitialized() )
+        return true;
+
+    QOpenGLContext* context = QOpenGLContext::currentContext();
+
+    // If owned by a context object make sure it is current.
+    // Also check that current context is capable of resolving all needed functions
+    if (((owningContext() && owningContext() == context) || !owningContext())
+        && QOpenGLFunctions_2_1::isContextCompatible(context))
+    {
+        // Associate with private implementation, creating if necessary
+        // Function pointers in the backends are resolved at creation time
+        QOpenGLVersionFunctionsBackend* d = 0;
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_0_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
+        }
+        d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_1_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
+        }
+        d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_2_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
+        }
+        d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_3_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
+        }
+        d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_4_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
+        }
+        d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_5_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
+        }
+        d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_2_0_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
+        }
+        d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_2_1_CoreBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
+        }
+        d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
+        }
+        d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
+        }
+        d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
+        }
+        d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
+        }
+        d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
+        }
+        d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
+        if (!d) {
+            d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
+            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
+        }
+        d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
+        d->refs.ref();
+
+        QAbstractOpenGLFunctions::initializeOpenGLFunctions();
+    }
+    return isInitialized();
+}
+
+bool QOpenGLFunctions_2_1::isContextCompatible(QOpenGLContext *context)
+{
+    Q_ASSERT(context);
+    QSurfaceFormat f = context->format();
+    const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
+    if (v < qMakePair(2, 1))
+        return false;
+
+    if (f.profile() == QSurfaceFormat::CoreProfile)
+        return false;
+
+    return true;
+}
+
+QOpenGLVersionProfile QOpenGLFunctions_2_1::versionProfile()
+{
+    QOpenGLVersionProfile v;
+    v.setVersion(2, 1);
+    return v;
+}
+
+QT_END_NAMESPACE