Remove OpenGL dependency from qTriangulate

The original implementation is only suitable as long as the only client
is the GL paint engine which will call the function with the GL context
current. In other cases this cannot be ensured. For instance, doing
triangulation on the gui thread in a Quick application using the threaded
render loop will have to deal with not having a current context on that
thread at all. Doing triangulation on worker threads has the same problem
as well.

In addition, in modern Qt versions a -no-opengl build does not imply no
accelerated graphics API.

Therefore, drop the ElementIndexUint check from qtriangulator.cpp and leave
it up to the caller to tell if uint indices are supported or not.

Change-Id: I7491d84981ee22d05c5fde08994dbb3a4e2432e9
Reviewed-by: Gunnar Sletta <gunnar@crimson.no>

3 files changed, 30 insertions, 33 deletions

diff --git a/src/gui/opengl/qopenglpaintengine.cpp b/src/gui/opengl/qopenglpaintengine.cpp
index 5c05a05d80..8db806f1d5 100644
--- a/src/gui/opengl/qopenglpaintengine.cpp
+++ b/src/gui/opengl/qopenglpaintengine.cpp
@@ -761,6 +761,8 @@ void QOpenGL2PaintEngineExPrivate::fill(const QVectorPath& path)
     if (matrixDirty)
         updateMatrix();
 
+    const bool supportsElementIndexUint = funcs.hasOpenGLExtension(QOpenGLExtensions::ElementIndexUint);
+
     const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());
 
     // Check to see if there's any hints
@@ -881,7 +883,7 @@ void QOpenGL2PaintEngineExPrivate::fill(const QVectorPath& path)
 
             // 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));
+                QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale), 1, supportsElementIndexUint);
                 cache->vertexCount = polys.vertices.size() / 2;
                 cache->indexCount = polys.indices.size();
                 cache->primitiveType = GL_TRIANGLES;
@@ -950,7 +952,7 @@ void QOpenGL2PaintEngineExPrivate::fill(const QVectorPath& path)
                                   && (bbox.top() > -0x8000 * inverseScale)
                                   && (bbox.bottom() < 0x8000 * inverseScale);
                 if (withinLimits) {
-                    QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale));
+                    QTriangleSet polys = qTriangulate(path, QTransform().scale(1 / inverseScale, 1 / inverseScale), 1, supportsElementIndexUint);
 
                     QVarLengthArray<float> vertices(polys.vertices.size());
                     for (int i = 0; i < polys.vertices.size(); ++i)
diff --git a/src/gui/painting/qtriangulator.cpp b/src/gui/painting/qtriangulator.cpp
index 6604d407f0..6d57eba123 100644
--- a/src/gui/painting/qtriangulator.cpp
+++ b/src/gui/painting/qtriangulator.cpp
@@ -50,10 +50,6 @@
 #include <QtCore/qglobal.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qalgorithms.h>
-#ifndef QT_NO_OPENGL
-# include <private/qopenglcontext_p.h>
-# include <private/qopenglextensions_p.h>
-#endif
 #include <private/qrbtree_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -2266,23 +2262,12 @@ void QTriangulator<T>::MonotoneToTriangles::decompose()
 //                                qTriangulate                                //
 //============================================================================//
 
-static bool hasElementIndexUint()
-{
-#ifndef QT_NO_OPENGL
-    QOpenGLContext *context = QOpenGLContext::currentContext();
-    if (!context)
-        return false;
-    return static_cast<QOpenGLExtensions *>(context->functions())->hasOpenGLExtension(QOpenGLExtensions::ElementIndexUint);
-#else
-    return false;
-#endif
-}
-
 Q_GUI_EXPORT QTriangleSet qTriangulate(const qreal *polygon,
-                          int count, uint hint, const QTransform &matrix)
+                                       int count, uint hint, const QTransform &matrix,
+                                       bool allowUintIndices)
 {
     QTriangleSet triangleSet;
-    if (hasElementIndexUint()) {
+    if (allowUintIndices) {
         QTriangulator<quint32> triangulator;
         triangulator.initialize(polygon, count, hint, matrix);
         QVertexSet<quint32> vertexSet = triangulator.triangulate();
@@ -2300,10 +2285,13 @@ Q_GUI_EXPORT QTriangleSet qTriangulate(const qreal *polygon,
 }
 
 Q_GUI_EXPORT QTriangleSet qTriangulate(const QVectorPath &path,
-                          const QTransform &matrix, qreal lod)
+                                       const QTransform &matrix, qreal lod, bool allowUintIndices)
 {
     QTriangleSet triangleSet;
-    if (hasElementIndexUint()) {
+    // For now systems that support 32-bit index values will always get 32-bit
+    // index values. This is not necessary ideal since 16-bit would be enough in
+    // many cases. TODO revisit this at a later point.
+    if (allowUintIndices) {
         QTriangulator<quint32> triangulator;
         triangulator.initialize(path, matrix, lod);
         QVertexSet<quint32> vertexSet = triangulator.triangulate();
@@ -2320,10 +2308,10 @@ Q_GUI_EXPORT QTriangleSet qTriangulate(const QVectorPath &path,
 }
 
 QTriangleSet qTriangulate(const QPainterPath &path,
-                          const QTransform &matrix, qreal lod)
+                          const QTransform &matrix, qreal lod, bool allowUintIndices)
 {
     QTriangleSet triangleSet;
-    if (hasElementIndexUint()) {
+    if (allowUintIndices) {
         QTriangulator<quint32> triangulator;
         triangulator.initialize(path, matrix, lod);
         QVertexSet<quint32> vertexSet = triangulator.triangulate();
@@ -2340,10 +2328,10 @@ QTriangleSet qTriangulate(const QPainterPath &path,
 }
 
 QPolylineSet qPolyline(const QVectorPath &path,
-                       const QTransform &matrix, qreal lod)
+                       const QTransform &matrix, qreal lod, bool allowUintIndices)
 {
     QPolylineSet polyLineSet;
-    if (hasElementIndexUint()) {
+    if (allowUintIndices) {
         QTriangulator<quint32> triangulator;
         triangulator.initialize(path, matrix, lod);
         QVertexSet<quint32> vertexSet = triangulator.polyline();
@@ -2360,10 +2348,10 @@ QPolylineSet qPolyline(const QVectorPath &path,
 }
 
 QPolylineSet qPolyline(const QPainterPath &path,
-                       const QTransform &matrix, qreal lod)
+                       const QTransform &matrix, qreal lod, bool allowUintIndices)
 {
     QPolylineSet polyLineSet;
-    if (hasElementIndexUint()) {
+    if (allowUintIndices) {
         QTriangulator<quint32> triangulator;
         triangulator.initialize(path, matrix, lod);
         QVertexSet<quint32> vertexSet = triangulator.polyline();
diff --git a/src/gui/painting/qtriangulator_p.h b/src/gui/painting/qtriangulator_p.h
index 4d1aba099c..8f043fc925 100644
--- a/src/gui/painting/qtriangulator_p.h
+++ b/src/gui/painting/qtriangulator_p.h
@@ -137,11 +137,18 @@ struct Q_GUI_EXPORT QPolylineSet
 // integers, the polygon is triangulated, and then scaled back by 1/32.
 // 'hint' should be a combination of QVectorPath::Hints.
 // 'lod' is the level of detail. Default is 1. Curves are split into more lines when 'lod' is higher.
-QTriangleSet Q_GUI_EXPORT qTriangulate(const qreal *polygon, int count, uint hint = QVectorPath::PolygonHint | QVectorPath::OddEvenFill, const QTransform &matrix = QTransform());
-QTriangleSet Q_GUI_EXPORT qTriangulate(const QVectorPath &path, const QTransform &matrix = QTransform(), qreal lod = 1);
-QTriangleSet Q_GUI_EXPORT qTriangulate(const QPainterPath &path, const QTransform &matrix = QTransform(), qreal lod = 1);
-QPolylineSet qPolyline(const QVectorPath &path, const QTransform &matrix = QTransform(), qreal lod = 1);
-QPolylineSet Q_GUI_EXPORT qPolyline(const QPainterPath &path, const QTransform &matrix = QTransform(), qreal lod = 1);
+QTriangleSet Q_GUI_EXPORT qTriangulate(const qreal *polygon, int count,
+                                       uint hint = QVectorPath::PolygonHint | QVectorPath::OddEvenFill,
+                                       const QTransform &matrix = QTransform(),
+                                       bool allowUintIndices = true);
+QTriangleSet Q_GUI_EXPORT qTriangulate(const QVectorPath &path, const QTransform &matrix = QTransform(),
+                                       qreal lod = 1, bool allowUintIndices = true);
+QTriangleSet Q_GUI_EXPORT qTriangulate(const QPainterPath &path, const QTransform &matrix = QTransform(),
+                                       qreal lod = 1, bool allowUintIndices = true);
+QPolylineSet qPolyline(const QVectorPath &path, const QTransform &matrix = QTransform(),
+                       qreal lod = 1, bool allowUintIndices = true);
+QPolylineSet Q_GUI_EXPORT qPolyline(const QPainterPath &path, const QTransform &matrix = QTransform(),
+                                    qreal lod = 1, bool allowUintIndices = true);
 
 QT_END_NAMESPACE