Port Map*ObjectPrivateQSG to the shader-based projection geometriesv5.15.0-alpha1

This patch changes the implementation of the scenegraph-based
mapobjects (those created by QGeoTiledMap) to be the recently
introduced one sporting shader-based map projection.
This is much faster than the previous, but may introduce small glitches
at this time (mostly on minified polylines).
Adding polyline LOD simplification will solve this problem.

Compared to equivalent Map Items (that is, Map Items backed by the
same underlying implementation), map objects now are approximately
1.5x faster.
This measure has been gathered using medium-size polygons (contained
in the file 10_countries.json from the geojson_viewer example).
The difference is caused by the additional QtQuick geometry related
operations (essentially projecting the bounding box for each item)
present in MapItems.
Smaller polygons may therefore yield larger improvements, larger polygons
the opposite.

Change-Id: I3fc92b02b74a3a4d001e69755949a98f80d8a3d3
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

1 files changed, 213 insertions, 53 deletions

diff --git a/src/location/labs/qsg/qmapcircleobjectqsg.cpp b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
index 6c69ce5a..5b1f5361 100644
--- a/src/location/labs/qsg/qmapcircleobjectqsg.cpp
+++ b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
@@ -41,16 +41,19 @@ QT_BEGIN_NAMESPACE
 static const int CircleSamples = 128;
 
 QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(QGeoMapObject *q)
-    : QMapCircleObjectPrivateDefault(q)
+    : QMapCircleObjectPrivateDefault(q), m_dataCPU(new CircleDataCPU)
 {
 
 }
 
 QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other)
-    : QMapCircleObjectPrivateDefault(other)
+    : QMapCircleObjectPrivateDefault(other), m_dataCPU(new CircleDataCPU)
 {
     // Data already cloned by the *Default copy constructor, but necessary
     // update operations triggered only by setters overrides
+    if (!QDeclarativeCircleMapItemPrivateCPU::crossEarthPole(center(), radius()))
+        switchToGL(); // this marks source dirty
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -62,47 +65,54 @@ QMapCircleObjectPrivateQSG::~QMapCircleObjectPrivateQSG()
         m_map->removeMapObject(q);
 }
 
-void QMapCircleObjectPrivateQSG::updateCirclePath()
+void QMapCircleObjectPrivateQSG::updateGeometry()
+{
+    if (!m_dataGL.isNull())
+        updateGeometryGL();
+    else
+        updateGeometryCPU();
+}
+
+void QMapCircleObjectPrivateQSG::CircleDataCPU::updateCirclePath(const QGeoCoordinate &center, qreal radius, const QGeoProjectionWebMercator &p)
 {
-    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
     QList<QGeoCoordinate> path;
-    QDeclarativeCircleMapItemPrivateCPU::calculatePeripheralPoints(path, center(), radius(), CircleSamples, m_leftBound);
+    QDeclarativeCircleMapItemPrivateCPU::calculatePeripheralPoints(path, center, radius, CircleSamples, m_leftBound);
     m_circlePath.clear();
     for (const QGeoCoordinate &c : path)
         m_circlePath << p.geoToMapProjection(c);
 }
 
-void QMapCircleObjectPrivateQSG::updateGeometry()
+void QMapCircleObjectPrivateQSG::updateGeometryCPU()
 {
     if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator
             || !qIsFinite(radius()) || !center().isValid())
         return;
 
     const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
-    QScopedValueRollback<bool> rollback(m_updatingGeometry);
-    m_updatingGeometry = true;
+    QScopedValueRollback<bool> rollback(m_dataCPU->m_updatingGeometry);
+    m_dataCPU->m_updatingGeometry = true;
 
-    updateCirclePath();
-    QList<QDoubleVector2D> circlePath = m_circlePath;
+    m_dataCPU->updateCirclePath(center(), radius(), p);
+    QList<QDoubleVector2D> circlePath = m_dataCPU->m_circlePath;
 
     int pathCount = circlePath.size();
     bool preserve = QDeclarativeCircleMapItemPrivateCPU::preserveCircleGeometry(circlePath, center(), radius(), p);
     // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft());
     // to fix QTBUG-62154
-    m_geometry.markSourceDirty();
-    m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_
-    m_geometry.setPreserveGeometry(preserve, m_leftBound);
+    m_dataCPU->m_geometry.markSourceDirty();
+    m_dataCPU->m_geometry.setPreserveGeometry(true, m_dataCPU->m_leftBound); // to set the geoLeftBound_
+    m_dataCPU->m_geometry.setPreserveGeometry(preserve, m_dataCPU->m_leftBound);
 
     bool invertedCircle = false;
     if (QDeclarativeCircleMapItemPrivateCPU::crossEarthPole(center(), radius()) && circlePath.size() == pathCount) {
-        m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles
+        m_dataCPU->m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles
         invertedCircle = true;
     } else {
-        m_geometry.updateSourcePoints(*m_map, circlePath);
-        m_geometry.updateScreenPoints(*m_map);
+        m_dataCPU->m_geometry.updateSourcePoints(*m_map, circlePath);
+        m_dataCPU->m_geometry.updateScreenPoints(*m_map);
     }
 
-    m_borderGeometry.clear();
+    m_dataCPU->m_borderGeometry.clear();
 
     //if (borderColor() != Qt::transparent && borderWidth() > 0)
     {
@@ -110,35 +120,76 @@ void QMapCircleObjectPrivateQSG::updateGeometry()
         closedPath << closedPath.first();
 
         if (invertedCircle) {
-            closedPath = m_circlePath;
+            closedPath = m_dataCPU->m_circlePath;
             closedPath << closedPath.first();
             std::reverse(closedPath.begin(), closedPath.end());
         }
 
-        m_borderGeometry.markSourceDirty();
-        m_borderGeometry.setPreserveGeometry(true, m_leftBound);
-        m_borderGeometry.setPreserveGeometry(preserve, m_leftBound);
+        m_dataCPU->m_borderGeometry.markSourceDirty();
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(true, m_dataCPU->m_leftBound);
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(preserve, m_dataCPU->m_leftBound);
 
         // Use srcOrigin_ from fill geometry after clipping to ensure that translateToCommonOrigin won't fail.
-        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+        const QGeoCoordinate &geometryOrigin = m_dataCPU->m_geometry.origin();
 
-        m_borderGeometry.clearSource();
+        m_dataCPU->m_borderGeometry.clearSource();
 
         QDoubleVector2D borderLeftBoundWrapped;
         QList<QList<QDoubleVector2D > > clippedPaths =
-                m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped);
+                m_dataCPU->m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped);
         if (clippedPaths.size()) {
             borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
-            m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped);
-            m_borderGeometry.updateScreenPoints(*m_map, borderWidth(), false);
+            m_dataCPU->m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped);
+            m_dataCPU->m_borderGeometry.updateScreenPoints(*m_map, borderWidth(), false);
         } else {
-            m_borderGeometry.clear();
+            m_dataCPU->m_borderGeometry.clear();
         }
     }
 
-    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF();
-    m_geometry.translate(origin - m_geometry.firstPointOffset());
-    m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset());
+    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_dataCPU->m_geometry.origin(), false).toPointF();
+    m_dataCPU->m_geometry.translate(origin - m_dataCPU->m_geometry.firstPointOffset());
+    m_dataCPU->m_borderGeometry.translate(origin - m_dataCPU->m_borderGeometry.firstPointOffset());
+}
+
+void QMapCircleObjectPrivateQSG::CircleDataGL::updateCirclePath(const QGeoCoordinate &center, qreal radius, const QGeoProjectionWebMercator &p)
+{
+    m_circlePath.clear();
+    if (radius < 0.001) // 1mm is small enough, probably already way too small.
+        return;
+    QDeclarativeCircleMapItemPrivate::calculatePeripheralPoints(m_circlePath,
+                                                                center,
+                                                                radius,
+                                                                CircleSamples,
+                                                                m_leftBound);
+
+    m_leftBoundMercator = p.geoToMapProjection(m_leftBound);
+    m_geometry.setPreserveGeometry(true, m_leftBound);
+    m_borderGeometry.setPreserveGeometry(true, m_leftBound);
+}
+
+void QMapCircleObjectPrivateQSG::updateGeometryGL()
+{
+    if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    if (m_dataGL->m_geometry.isSourceDirty()
+            || m_dataGL->m_borderGeometry.isSourceDirty()) {
+        m_dataGL->updateCirclePath(center(), radius(), p);
+
+        if (m_dataGL->m_circlePath.length() == 0) { // Possibly cleared
+            m_dataGL->m_geometry.clear();
+            m_dataGL->m_borderGeometry.clear();
+            return;
+        }
+        m_dataGL->m_geometry.m_dataChanged = m_dataGL->m_borderGeometry.m_dataChanged = true;
+        m_dataGL->m_geometry.updateSourcePoints(*m_map, m_dataGL->m_circlePath);
+        m_dataGL->m_borderGeometry.updateSourcePoints(*m_map, QGeoCircle(center(), radius()));
+        m_dataGL->m_circlePath.clear(); // not needed anymore
+    }
+    m_dataGL->m_geometry.markScreenDirty();       // ToDo: this needs refactor. It's useless, remove screenDirty_ altogether.
+    m_dataGL->m_borderGeometry.markScreenDirty();
+    m_dataGL->m_borderGeometry.m_wrapOffset = m_dataGL->m_geometry.m_wrapOffset = p.projectionWrapFactor(m_dataGL->m_leftBoundMercator) + 1;
 }
 
 QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone()
@@ -146,45 +197,144 @@ QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone()
     return new QMapCircleObjectPrivateQSG(static_cast<QMapCircleObjectPrivate &>(*this));
 }
 
+void QMapCircleObjectPrivateQSG::switchToGL()
+{
+    if (!m_dataGL.isNull())
+        return;
+    QScopedPointer<CircleDataGL> data(new CircleDataGL);
+    m_dataGL.swap(data);
+    m_dataGL->markSourceDirty();
+    m_dataCPU.reset(nullptr);
+}
+
+void QMapCircleObjectPrivateQSG::switchToCPU()
+{
+    if (!m_dataCPU.isNull())
+        return;
+    QScopedPointer<CircleDataCPU> data(new CircleDataCPU);
+    m_dataCPU.swap(data);
+    m_dataGL.reset(nullptr);
+}
+
 QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode,
                                                          VisibleNode **visibleNode,
                                                          QSGNode *root,
-                                                         QQuickWindow * /*window*/)
+                                                         QQuickWindow * window)
 {
-//    Q_UNUSED(visibleNode); // coz of -Werror=unused-but-set-parameter
-    MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode);
+    if (!m_dataGL.isNull())
+        return updateMapObjectNodeGL(oldNode, visibleNode, root, window);
+    else
+        return updateMapObjectNodeCPU(oldNode, visibleNode, root, window);
+}
 
-    if (!node) {
-        if (!m_geometry.size() && !m_borderGeometry.size()) {
-            return nullptr;
-        }
-        node = new MapPolygonNode();
-        *visibleNode = static_cast<VisibleNode *>(node);
+QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNodeCPU(QSGNode *oldNode,
+                                                            VisibleNode **visibleNode,
+                                                            QSGNode *root,
+                                                            QQuickWindow */*window*/)
+{
+    if (!m_dataCPU->m_node || !oldNode) {
+        m_dataCPU->m_node = new MapPolygonNode();
+        *visibleNode = static_cast<VisibleNode *>(m_dataCPU->m_node);
+        if (oldNode)
+            delete oldNode;
+    } else {
+        m_dataCPU->m_node = static_cast<MapPolygonNode *>(oldNode);
+    }
+
+    if (!m_dataCPU->m_geometry.size() && !m_dataCPU->m_borderGeometry.size()) {
+        visibleNode = nullptr;
+        return nullptr;
     }
 
     //TODO: update only material
-    if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode) {
+    if (m_dataCPU->m_geometry.isScreenDirty() || m_dataCPU->m_borderGeometry.isScreenDirty() || oldNode != m_dataCPU->m_node) {
         //QMapPolygonObject *p = static_cast<QMapPolygonObject *>(q);
-        node->update(color(), borderColor(), &m_geometry, &m_borderGeometry);
-        m_geometry.setPreserveGeometry(false);
-        m_borderGeometry.setPreserveGeometry(false);
-        m_geometry.markClean();
-        m_borderGeometry.markClean();
+        m_dataCPU->m_node->update(color(), borderColor(), &m_dataCPU->m_geometry, &m_dataCPU->m_borderGeometry);
+        m_dataCPU->m_geometry.setPreserveGeometry(false);
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(false);
+        m_dataCPU->m_geometry.markClean();
+        m_dataCPU->m_borderGeometry.markClean();
     }
 
-    if (m_geometry.size() || m_borderGeometry.size()) {
-        root->appendChildNode(node);
+    if (m_dataCPU->m_geometry.size() || m_dataCPU->m_borderGeometry.size()) {
+        root->appendChildNode(m_dataCPU->m_node);
     } else {
-        delete node;
+        delete m_dataCPU->m_node;
+        m_dataCPU->m_node = nullptr;
+        visibleNode = nullptr;
         return nullptr;
     }
-    return node;
+    return m_dataCPU->m_node;
 }
 
+QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNodeGL(QSGNode *oldNode,
+                                                           VisibleNode **visibleNode,
+                                                           QSGNode *root,
+                                                           QQuickWindow */*window*/)
+{
+    if (!m_dataGL->m_rootNode || !oldNode) {
+        m_dataGL->m_rootNode = new QDeclarativePolygonMapItemPrivateOpenGL::RootNode();
+        m_dataGL->m_node = new MapPolygonNodeGL();
+        m_dataGL->m_rootNode->appendChildNode(m_dataGL->m_node);
+        m_dataGL->m_polylinenode = new MapPolylineNodeOpenGLExtruded();
+        m_dataGL->m_rootNode->appendChildNode(m_dataGL->m_polylinenode);
+        m_dataGL->m_rootNode->markDirty(QSGNode::DirtyNodeAdded);
+        *visibleNode = static_cast<VisibleNode *>(m_dataGL->m_rootNode);
+        if (oldNode)
+            delete oldNode;
+    } else {
+        m_dataGL->m_rootNode = static_cast<QDeclarativePolygonMapItemPrivateOpenGL::RootNode *>(oldNode);
+    }
+
+    const QMatrix4x4 &combinedMatrix = m_map->geoProjection().qsgTransform();
+    const QDoubleVector3D &cameraCenter = m_map->geoProjection().centerMercator();
+
+    if (m_dataGL->m_borderGeometry.isScreenDirty()) {
+        /* Do the border update first */
+        m_dataGL->m_polylinenode->update(borderColor(),
+                               float(borderWidth()),
+                               &m_dataGL->m_borderGeometry,
+                               combinedMatrix,
+                               cameraCenter,
+                               Qt::SquareCap,
+                               true);
+        m_dataGL->m_borderGeometry.setPreserveGeometry(false);
+        m_dataGL->m_borderGeometry.markClean();
+    }
+    if (m_dataGL->m_geometry.isScreenDirty()) {
+        m_dataGL->m_node->update(color(),
+                     &m_dataGL->m_geometry,
+                     combinedMatrix,
+                     cameraCenter);
+        m_dataGL->m_geometry.setPreserveGeometry(false);
+        m_dataGL->m_geometry.markClean();
+    }
+
+    if (!m_dataGL->m_polylinenode->isSubtreeBlocked() || !m_dataGL->m_node->isSubtreeBlocked()) {
+        m_dataGL->m_rootNode->setSubtreeBlocked(false);
+        root->appendChildNode(m_dataGL->m_rootNode);
+        return m_dataGL->m_rootNode;
+    } else {
+        delete m_dataGL->m_rootNode;
+        m_dataGL->m_rootNode = nullptr;
+        m_dataGL->m_node = nullptr;
+        m_dataGL->m_polylinenode = nullptr;
+        *visibleNode = nullptr;
+        return nullptr;
+    }
+}
 
 void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate &center)
 {
     QMapCircleObjectPrivateDefault::setCenter(center);
+    if (!QDeclarativeCircleMapItemPrivate::crossEarthPole(this->center(), this->radius())) // Switching implementation for circles crossing/not crossing poles
+        switchToGL();
+    else
+        switchToCPU();
+
+    if (!m_dataGL.isNull())
+        m_dataGL->markSourceDirty();
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -193,6 +343,14 @@ void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate &center)
 void QMapCircleObjectPrivateQSG::setRadius(qreal radius)
 {
     QMapCircleObjectPrivateDefault::setRadius(radius);
+    if (!QDeclarativeCircleMapItemPrivate::crossEarthPole(this->center(), this->radius())) // Switching implementation for circles crossing/not crossing poles
+        switchToGL();
+    else
+        switchToCPU();
+
+    if (!m_dataGL.isNull())
+        m_dataGL->markSourceDirty();
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -201,7 +359,8 @@ void QMapCircleObjectPrivateQSG::setRadius(qreal radius)
 void QMapCircleObjectPrivateQSG::setColor(const QColor &color)
 {
     QMapCircleObjectPrivateDefault::setColor(color);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
@@ -209,7 +368,8 @@ void QMapCircleObjectPrivateQSG::setColor(const QColor &color)
 void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color)
 {
     QMapCircleObjectPrivateDefault::setBorderColor(color);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
@@ -217,10 +377,10 @@ void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color)
 void QMapCircleObjectPrivateQSG::setBorderWidth(qreal width)
 {
     QMapCircleObjectPrivateDefault::setBorderWidth(width);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
 
-
 QT_END_NAMESPACE